diff --git a/parrot/lib/python3.10/site-packages/charset_normalizer-3.3.2.dist-info/INSTALLER b/parrot/lib/python3.10/site-packages/charset_normalizer-3.3.2.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/charset_normalizer-3.3.2.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/parrot/lib/python3.10/site-packages/charset_normalizer-3.3.2.dist-info/LICENSE b/parrot/lib/python3.10/site-packages/charset_normalizer-3.3.2.dist-info/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..ad82355b802d542e8443dc78b937fa36fdcc0ace
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/charset_normalizer-3.3.2.dist-info/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 TAHRI Ahmed R.
+
+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.
\ No newline at end of file
diff --git a/parrot/lib/python3.10/site-packages/charset_normalizer-3.3.2.dist-info/METADATA b/parrot/lib/python3.10/site-packages/charset_normalizer-3.3.2.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..822550e36bfc53472baf4f4d059b878817c87496
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/charset_normalizer-3.3.2.dist-info/METADATA
@@ -0,0 +1,683 @@
+Metadata-Version: 2.1
+Name: charset-normalizer
+Version: 3.3.2
+Summary: The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet.
+Home-page: https://github.com/Ousret/charset_normalizer
+Author: Ahmed TAHRI
+Author-email: ahmed.tahri@cloudnursery.dev
+License: MIT
+Project-URL: Bug Reports, https://github.com/Ousret/charset_normalizer/issues
+Project-URL: Documentation, https://charset-normalizer.readthedocs.io/en/latest
+Keywords: encoding,charset,charset-detector,detector,normalization,unicode,chardet,detect
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Text Processing :: Linguistic
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Python: >=3.7.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: unicode_backport
+
+Charset Detection, for Everyone π
+
+
+ The Real First Universal Charset Detector
+
+ 
+
+
+ 
+
+
+ 
+
+
+
+ Featured Packages
+
+ 
+
+
+ 
+
+
+
+ In other language (unofficial port - by the community)
+
+ 
+
+
+
+> A library that helps you read text from an unknown charset encoding.
Motivated by `chardet`,
+> I'm trying to resolve the issue by taking a new approach.
+> All IANA character set names for which the Python core library provides codecs are supported.
+
+
+ >>>>> π Try Me Online Now, Then Adopt Me π <<<<<
+
+
+This project offers you an alternative to **Universal Charset Encoding Detector**, also known as **Chardet**.
+
+| Feature | [Chardet](https://github.com/chardet/chardet) | Charset Normalizer | [cChardet](https://github.com/PyYoshi/cChardet) |
+|--------------------------------------------------|:---------------------------------------------:|:--------------------------------------------------------------------------------------------------:|:-----------------------------------------------:|
+| `Fast` | β | β
| β
|
+| `Universal**` | β | β
| β |
+| `Reliable` **without** distinguishable standards | β | β
| β
|
+| `Reliable` **with** distinguishable standards | β
| β
| β
|
+| `License` | LGPL-2.1
_restrictive_ | MIT | MPL-1.1
_restrictive_ |
+| `Native Python` | β
| β
| β |
+| `Detect spoken language` | β | β
| N/A |
+| `UnicodeDecodeError Safety` | β | β
| β |
+| `Whl Size (min)` | 193.6 kB | 42 kB | ~200 kB |
+| `Supported Encoding` | 33 | π [99](https://charset-normalizer.readthedocs.io/en/latest/user/support.html#supported-encodings) | 40 |
+
+
+
+
+
+*\*\* : They are clearly using specific code for a specific encoding even if covering most of used one*
+Did you got there because of the logs? See [https://charset-normalizer.readthedocs.io/en/latest/user/miscellaneous.html](https://charset-normalizer.readthedocs.io/en/latest/user/miscellaneous.html)
+
+## β‘ Performance
+
+This package offer better performance than its counterpart Chardet. Here are some numbers.
+
+| Package | Accuracy | Mean per file (ms) | File per sec (est) |
+|-----------------------------------------------|:--------:|:------------------:|:------------------:|
+| [chardet](https://github.com/chardet/chardet) | 86 % | 200 ms | 5 file/sec |
+| charset-normalizer | **98 %** | **10 ms** | 100 file/sec |
+
+| Package | 99th percentile | 95th percentile | 50th percentile |
+|-----------------------------------------------|:---------------:|:---------------:|:---------------:|
+| [chardet](https://github.com/chardet/chardet) | 1200 ms | 287 ms | 23 ms |
+| charset-normalizer | 100 ms | 50 ms | 5 ms |
+
+Chardet's performance on larger file (1MB+) are very poor. Expect huge difference on large payload.
+
+> Stats are generated using 400+ files using default parameters. More details on used files, see GHA workflows.
+> And yes, these results might change at any time. The dataset can be updated to include more files.
+> The actual delays heavily depends on your CPU capabilities. The factors should remain the same.
+> Keep in mind that the stats are generous and that Chardet accuracy vs our is measured using Chardet initial capability
+> (eg. Supported Encoding) Challenge-them if you want.
+
+## β¨ Installation
+
+Using pip:
+
+```sh
+pip install charset-normalizer -U
+```
+
+## π Basic Usage
+
+### CLI
+This package comes with a CLI.
+
+```
+usage: normalizer [-h] [-v] [-a] [-n] [-m] [-r] [-f] [-t THRESHOLD]
+ file [file ...]
+
+The Real First Universal Charset Detector. Discover originating encoding used
+on text file. Normalize text to unicode.
+
+positional arguments:
+ files File(s) to be analysed
+
+optional arguments:
+ -h, --help show this help message and exit
+ -v, --verbose Display complementary information about file if any.
+ Stdout will contain logs about the detection process.
+ -a, --with-alternative
+ Output complementary possibilities if any. Top-level
+ JSON WILL be a list.
+ -n, --normalize Permit to normalize input file. If not set, program
+ does not write anything.
+ -m, --minimal Only output the charset detected to STDOUT. Disabling
+ JSON output.
+ -r, --replace Replace file when trying to normalize it instead of
+ creating a new one.
+ -f, --force Replace file without asking if you are sure, use this
+ flag with caution.
+ -t THRESHOLD, --threshold THRESHOLD
+ Define a custom maximum amount of chaos allowed in
+ decoded content. 0. <= chaos <= 1.
+ --version Show version information and exit.
+```
+
+```bash
+normalizer ./data/sample.1.fr.srt
+```
+
+or
+
+```bash
+python -m charset_normalizer ./data/sample.1.fr.srt
+```
+
+π Since version 1.4.0 the CLI produce easily usable stdout result in JSON format.
+
+```json
+{
+ "path": "/home/default/projects/charset_normalizer/data/sample.1.fr.srt",
+ "encoding": "cp1252",
+ "encoding_aliases": [
+ "1252",
+ "windows_1252"
+ ],
+ "alternative_encodings": [
+ "cp1254",
+ "cp1256",
+ "cp1258",
+ "iso8859_14",
+ "iso8859_15",
+ "iso8859_16",
+ "iso8859_3",
+ "iso8859_9",
+ "latin_1",
+ "mbcs"
+ ],
+ "language": "French",
+ "alphabets": [
+ "Basic Latin",
+ "Latin-1 Supplement"
+ ],
+ "has_sig_or_bom": false,
+ "chaos": 0.149,
+ "coherence": 97.152,
+ "unicode_path": null,
+ "is_preferred": true
+}
+```
+
+### Python
+*Just print out normalized text*
+```python
+from charset_normalizer import from_path
+
+results = from_path('./my_subtitle.srt')
+
+print(str(results.best()))
+```
+
+*Upgrade your code without effort*
+```python
+from charset_normalizer import detect
+```
+
+The above code will behave the same as **chardet**. We ensure that we offer the best (reasonable) BC result possible.
+
+See the docs for advanced usage : [readthedocs.io](https://charset-normalizer.readthedocs.io/en/latest/)
+
+## π Why
+
+When I started using Chardet, I noticed that it was not suited to my expectations, and I wanted to propose a
+reliable alternative using a completely different method. Also! I never back down on a good challenge!
+
+I **don't care** about the **originating charset** encoding, because **two different tables** can
+produce **two identical rendered string.**
+What I want is to get readable text, the best I can.
+
+In a way, **I'm brute forcing text decoding.** How cool is that ? π
+
+Don't confuse package **ftfy** with charset-normalizer or chardet. ftfy goal is to repair unicode string whereas charset-normalizer to convert raw file in unknown encoding to unicode.
+
+## π° How
+
+ - Discard all charset encoding table that could not fit the binary content.
+ - Measure noise, or the mess once opened (by chunks) with a corresponding charset encoding.
+ - Extract matches with the lowest mess detected.
+ - Additionally, we measure coherence / probe for a language.
+
+**Wait a minute**, what is noise/mess and coherence according to **YOU ?**
+
+*Noise :* I opened hundred of text files, **written by humans**, with the wrong encoding table. **I observed**, then
+**I established** some ground rules about **what is obvious** when **it seems like** a mess.
+ I know that my interpretation of what is noise is probably incomplete, feel free to contribute in order to
+ improve or rewrite it.
+
+*Coherence :* For each language there is on earth, we have computed ranked letter appearance occurrences (the best we can). So I thought
+that intel is worth something here. So I use those records against decoded text to check if I can detect intelligent design.
+
+## β‘ Known limitations
+
+ - Language detection is unreliable when text contains two or more languages sharing identical letters. (eg. HTML (english tags) + Turkish content (Sharing Latin characters))
+ - Every charset detector heavily depends on sufficient content. In common cases, do not bother run detection on very tiny content.
+
+## β οΈ About Python EOLs
+
+**If you are running:**
+
+- Python >=2.7,<3.5: Unsupported
+- Python 3.5: charset-normalizer < 2.1
+- Python 3.6: charset-normalizer < 3.1
+- Python 3.7: charset-normalizer < 4.0
+
+Upgrade your Python interpreter as soon as possible.
+
+## π€ Contributing
+
+Contributions, issues and feature requests are very much welcome.
+Feel free to check [issues page](https://github.com/ousret/charset_normalizer/issues) if you want to contribute.
+
+## π License
+
+Copyright Β© [Ahmed TAHRI @Ousret](https://github.com/Ousret).
+This project is [MIT](https://github.com/Ousret/charset_normalizer/blob/master/LICENSE) licensed.
+
+Characters frequencies used in this project Β© 2012 [Denny VrandeΔiΔ](http://simia.net/letters/)
+
+## πΌ For Enterprise
+
+Professional support for charset-normalizer 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-charset-normalizer?utm_source=pypi-charset-normalizer&utm_medium=readme
+
+# Changelog
+All notable changes to charset-normalizer will be documented in this file. This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
+
+## [3.3.2](https://github.com/Ousret/charset_normalizer/compare/3.3.1...3.3.2) (2023-10-31)
+
+### Fixed
+- Unintentional memory usage regression when using large payload that match several encoding (#376)
+- Regression on some detection case showcased in the documentation (#371)
+
+### Added
+- Noise (md) probe that identify malformed arabic representation due to the presence of letters in isolated form (credit to my wife)
+
+## [3.3.1](https://github.com/Ousret/charset_normalizer/compare/3.3.0...3.3.1) (2023-10-22)
+
+### Changed
+- Optional mypyc compilation upgraded to version 1.6.1 for Python >= 3.8
+- Improved the general detection reliability based on reports from the community
+
+## [3.3.0](https://github.com/Ousret/charset_normalizer/compare/3.2.0...3.3.0) (2023-09-30)
+
+### Added
+- Allow to execute the CLI (e.g. normalizer) through `python -m charset_normalizer.cli` or `python -m charset_normalizer`
+- Support for 9 forgotten encoding that are supported by Python but unlisted in `encoding.aliases` as they have no alias (#323)
+
+### Removed
+- (internal) Redundant utils.is_ascii function and unused function is_private_use_only
+- (internal) charset_normalizer.assets is moved inside charset_normalizer.constant
+
+### Changed
+- (internal) Unicode code blocks in constants are updated using the latest v15.0.0 definition to improve detection
+- Optional mypyc compilation upgraded to version 1.5.1 for Python >= 3.8
+
+### Fixed
+- Unable to properly sort CharsetMatch when both chaos/noise and coherence were close due to an unreachable condition in \_\_lt\_\_ (#350)
+
+## [3.2.0](https://github.com/Ousret/charset_normalizer/compare/3.1.0...3.2.0) (2023-06-07)
+
+### Changed
+- Typehint for function `from_path` no longer enforce `PathLike` as its first argument
+- Minor improvement over the global detection reliability
+
+### Added
+- Introduce function `is_binary` that relies on main capabilities, and optimized to detect binaries
+- Propagate `enable_fallback` argument throughout `from_bytes`, `from_path`, and `from_fp` that allow a deeper control over the detection (default True)
+- Explicit support for Python 3.12
+
+### Fixed
+- Edge case detection failure where a file would contain 'very-long' camel cased word (Issue #289)
+
+## [3.1.0](https://github.com/Ousret/charset_normalizer/compare/3.0.1...3.1.0) (2023-03-06)
+
+### Added
+- Argument `should_rename_legacy` for legacy function `detect` and disregard any new arguments without errors (PR #262)
+
+### Removed
+- Support for Python 3.6 (PR #260)
+
+### Changed
+- Optional speedup provided by mypy/c 1.0.1
+
+## [3.0.1](https://github.com/Ousret/charset_normalizer/compare/3.0.0...3.0.1) (2022-11-18)
+
+### Fixed
+- Multi-bytes cutter/chunk generator did not always cut correctly (PR #233)
+
+### Changed
+- Speedup provided by mypy/c 0.990 on Python >= 3.7
+
+## [3.0.0](https://github.com/Ousret/charset_normalizer/compare/2.1.1...3.0.0) (2022-10-20)
+
+### Added
+- Extend the capability of explain=True when cp_isolation contains at most two entries (min one), will log in details of the Mess-detector results
+- Support for alternative language frequency set in charset_normalizer.assets.FREQUENCIES
+- Add parameter `language_threshold` in `from_bytes`, `from_path` and `from_fp` to adjust the minimum expected coherence ratio
+- `normalizer --version` now specify if current version provide extra speedup (meaning mypyc compilation whl)
+
+### Changed
+- Build with static metadata using 'build' frontend
+- Make the language detection stricter
+- Optional: Module `md.py` can be compiled using Mypyc to provide an extra speedup up to 4x faster than v2.1
+
+### Fixed
+- CLI with opt --normalize fail when using full path for files
+- TooManyAccentuatedPlugin induce false positive on the mess detection when too few alpha character have been fed to it
+- Sphinx warnings when generating the documentation
+
+### Removed
+- Coherence detector no longer return 'Simple English' instead return 'English'
+- Coherence detector no longer return 'Classical Chinese' instead return 'Chinese'
+- Breaking: Method `first()` and `best()` from CharsetMatch
+- UTF-7 will no longer appear as "detected" without a recognized SIG/mark (is unreliable/conflict with ASCII)
+- Breaking: Class aliases CharsetDetector, CharsetDoctor, CharsetNormalizerMatch and CharsetNormalizerMatches
+- Breaking: Top-level function `normalize`
+- Breaking: Properties `chaos_secondary_pass`, `coherence_non_latin` and `w_counter` from CharsetMatch
+- Support for the backport `unicodedata2`
+
+## [3.0.0rc1](https://github.com/Ousret/charset_normalizer/compare/3.0.0b2...3.0.0rc1) (2022-10-18)
+
+### Added
+- Extend the capability of explain=True when cp_isolation contains at most two entries (min one), will log in details of the Mess-detector results
+- Support for alternative language frequency set in charset_normalizer.assets.FREQUENCIES
+- Add parameter `language_threshold` in `from_bytes`, `from_path` and `from_fp` to adjust the minimum expected coherence ratio
+
+### Changed
+- Build with static metadata using 'build' frontend
+- Make the language detection stricter
+
+### Fixed
+- CLI with opt --normalize fail when using full path for files
+- TooManyAccentuatedPlugin induce false positive on the mess detection when too few alpha character have been fed to it
+
+### Removed
+- Coherence detector no longer return 'Simple English' instead return 'English'
+- Coherence detector no longer return 'Classical Chinese' instead return 'Chinese'
+
+## [3.0.0b2](https://github.com/Ousret/charset_normalizer/compare/3.0.0b1...3.0.0b2) (2022-08-21)
+
+### Added
+- `normalizer --version` now specify if current version provide extra speedup (meaning mypyc compilation whl)
+
+### Removed
+- Breaking: Method `first()` and `best()` from CharsetMatch
+- UTF-7 will no longer appear as "detected" without a recognized SIG/mark (is unreliable/conflict with ASCII)
+
+### Fixed
+- Sphinx warnings when generating the documentation
+
+## [3.0.0b1](https://github.com/Ousret/charset_normalizer/compare/2.1.0...3.0.0b1) (2022-08-15)
+
+### Changed
+- Optional: Module `md.py` can be compiled using Mypyc to provide an extra speedup up to 4x faster than v2.1
+
+### Removed
+- Breaking: Class aliases CharsetDetector, CharsetDoctor, CharsetNormalizerMatch and CharsetNormalizerMatches
+- Breaking: Top-level function `normalize`
+- Breaking: Properties `chaos_secondary_pass`, `coherence_non_latin` and `w_counter` from CharsetMatch
+- Support for the backport `unicodedata2`
+
+## [2.1.1](https://github.com/Ousret/charset_normalizer/compare/2.1.0...2.1.1) (2022-08-19)
+
+### Deprecated
+- Function `normalize` scheduled for removal in 3.0
+
+### Changed
+- Removed useless call to decode in fn is_unprintable (#206)
+
+### Fixed
+- Third-party library (i18n xgettext) crashing not recognizing utf_8 (PEP 263) with underscore from [@aleksandernovikov](https://github.com/aleksandernovikov) (#204)
+
+## [2.1.0](https://github.com/Ousret/charset_normalizer/compare/2.0.12...2.1.0) (2022-06-19)
+
+### Added
+- Output the Unicode table version when running the CLI with `--version` (PR #194)
+
+### Changed
+- Re-use decoded buffer for single byte character sets from [@nijel](https://github.com/nijel) (PR #175)
+- Fixing some performance bottlenecks from [@deedy5](https://github.com/deedy5) (PR #183)
+
+### Fixed
+- Workaround potential bug in cpython with Zero Width No-Break Space located in Arabic Presentation Forms-B, Unicode 1.1 not acknowledged as space (PR #175)
+- CLI default threshold aligned with the API threshold from [@oleksandr-kuzmenko](https://github.com/oleksandr-kuzmenko) (PR #181)
+
+### Removed
+- Support for Python 3.5 (PR #192)
+
+### Deprecated
+- Use of backport unicodedata from `unicodedata2` as Python is quickly catching up, scheduled for removal in 3.0 (PR #194)
+
+## [2.0.12](https://github.com/Ousret/charset_normalizer/compare/2.0.11...2.0.12) (2022-02-12)
+
+### Fixed
+- ASCII miss-detection on rare cases (PR #170)
+
+## [2.0.11](https://github.com/Ousret/charset_normalizer/compare/2.0.10...2.0.11) (2022-01-30)
+
+### Added
+- Explicit support for Python 3.11 (PR #164)
+
+### Changed
+- The logging behavior have been completely reviewed, now using only TRACE and DEBUG levels (PR #163 #165)
+
+## [2.0.10](https://github.com/Ousret/charset_normalizer/compare/2.0.9...2.0.10) (2022-01-04)
+
+### Fixed
+- Fallback match entries might lead to UnicodeDecodeError for large bytes sequence (PR #154)
+
+### Changed
+- Skipping the language-detection (CD) on ASCII (PR #155)
+
+## [2.0.9](https://github.com/Ousret/charset_normalizer/compare/2.0.8...2.0.9) (2021-12-03)
+
+### Changed
+- Moderating the logging impact (since 2.0.8) for specific environments (PR #147)
+
+### Fixed
+- Wrong logging level applied when setting kwarg `explain` to True (PR #146)
+
+## [2.0.8](https://github.com/Ousret/charset_normalizer/compare/2.0.7...2.0.8) (2021-11-24)
+### Changed
+- Improvement over Vietnamese detection (PR #126)
+- MD improvement on trailing data and long foreign (non-pure latin) data (PR #124)
+- Efficiency improvements in cd/alphabet_languages from [@adbar](https://github.com/adbar) (PR #122)
+- call sum() without an intermediary list following PEP 289 recommendations from [@adbar](https://github.com/adbar) (PR #129)
+- Code style as refactored by Sourcery-AI (PR #131)
+- Minor adjustment on the MD around european words (PR #133)
+- Remove and replace SRTs from assets / tests (PR #139)
+- Initialize the library logger with a `NullHandler` by default from [@nmaynes](https://github.com/nmaynes) (PR #135)
+- Setting kwarg `explain` to True will add provisionally (bounded to function lifespan) a specific stream handler (PR #135)
+
+### Fixed
+- Fix large (misleading) sequence giving UnicodeDecodeError (PR #137)
+- Avoid using too insignificant chunk (PR #137)
+
+### Added
+- Add and expose function `set_logging_handler` to configure a specific StreamHandler from [@nmaynes](https://github.com/nmaynes) (PR #135)
+- Add `CHANGELOG.md` entries, format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) (PR #141)
+
+## [2.0.7](https://github.com/Ousret/charset_normalizer/compare/2.0.6...2.0.7) (2021-10-11)
+### Added
+- Add support for Kazakh (Cyrillic) language detection (PR #109)
+
+### Changed
+- Further, improve inferring the language from a given single-byte code page (PR #112)
+- Vainly trying to leverage PEP263 when PEP3120 is not supported (PR #116)
+- Refactoring for potential performance improvements in loops from [@adbar](https://github.com/adbar) (PR #113)
+- Various detection improvement (MD+CD) (PR #117)
+
+### Removed
+- Remove redundant logging entry about detected language(s) (PR #115)
+
+### Fixed
+- Fix a minor inconsistency between Python 3.5 and other versions regarding language detection (PR #117 #102)
+
+## [2.0.6](https://github.com/Ousret/charset_normalizer/compare/2.0.5...2.0.6) (2021-09-18)
+### Fixed
+- Unforeseen regression with the loss of the backward-compatibility with some older minor of Python 3.5.x (PR #100)
+- Fix CLI crash when using --minimal output in certain cases (PR #103)
+
+### Changed
+- Minor improvement to the detection efficiency (less than 1%) (PR #106 #101)
+
+## [2.0.5](https://github.com/Ousret/charset_normalizer/compare/2.0.4...2.0.5) (2021-09-14)
+### Changed
+- The project now comply with: flake8, mypy, isort and black to ensure a better overall quality (PR #81)
+- The BC-support with v1.x was improved, the old staticmethods are restored (PR #82)
+- The Unicode detection is slightly improved (PR #93)
+- Add syntax sugar \_\_bool\_\_ for results CharsetMatches list-container (PR #91)
+
+### Removed
+- The project no longer raise warning on tiny content given for detection, will be simply logged as warning instead (PR #92)
+
+### Fixed
+- In some rare case, the chunks extractor could cut in the middle of a multi-byte character and could mislead the mess detection (PR #95)
+- Some rare 'space' characters could trip up the UnprintablePlugin/Mess detection (PR #96)
+- The MANIFEST.in was not exhaustive (PR #78)
+
+## [2.0.4](https://github.com/Ousret/charset_normalizer/compare/2.0.3...2.0.4) (2021-07-30)
+### Fixed
+- The CLI no longer raise an unexpected exception when no encoding has been found (PR #70)
+- Fix accessing the 'alphabets' property when the payload contains surrogate characters (PR #68)
+- The logger could mislead (explain=True) on detected languages and the impact of one MBCS match (PR #72)
+- Submatch factoring could be wrong in rare edge cases (PR #72)
+- Multiple files given to the CLI were ignored when publishing results to STDOUT. (After the first path) (PR #72)
+- Fix line endings from CRLF to LF for certain project files (PR #67)
+
+### Changed
+- Adjust the MD to lower the sensitivity, thus improving the global detection reliability (PR #69 #76)
+- Allow fallback on specified encoding if any (PR #71)
+
+## [2.0.3](https://github.com/Ousret/charset_normalizer/compare/2.0.2...2.0.3) (2021-07-16)
+### Changed
+- Part of the detection mechanism has been improved to be less sensitive, resulting in more accurate detection results. Especially ASCII. (PR #63)
+- According to the community wishes, the detection will fall back on ASCII or UTF-8 in a last-resort case. (PR #64)
+
+## [2.0.2](https://github.com/Ousret/charset_normalizer/compare/2.0.1...2.0.2) (2021-07-15)
+### Fixed
+- Empty/Too small JSON payload miss-detection fixed. Report from [@tseaver](https://github.com/tseaver) (PR #59)
+
+### Changed
+- Don't inject unicodedata2 into sys.modules from [@akx](https://github.com/akx) (PR #57)
+
+## [2.0.1](https://github.com/Ousret/charset_normalizer/compare/2.0.0...2.0.1) (2021-07-13)
+### Fixed
+- Make it work where there isn't a filesystem available, dropping assets frequencies.json. Report from [@sethmlarson](https://github.com/sethmlarson). (PR #55)
+- Using explain=False permanently disable the verbose output in the current runtime (PR #47)
+- One log entry (language target preemptive) was not show in logs when using explain=True (PR #47)
+- Fix undesired exception (ValueError) on getitem of instance CharsetMatches (PR #52)
+
+### Changed
+- Public function normalize default args values were not aligned with from_bytes (PR #53)
+
+### Added
+- You may now use charset aliases in cp_isolation and cp_exclusion arguments (PR #47)
+
+## [2.0.0](https://github.com/Ousret/charset_normalizer/compare/1.4.1...2.0.0) (2021-07-02)
+### Changed
+- 4x to 5 times faster than the previous 1.4.0 release. At least 2x faster than Chardet.
+- Accent has been made on UTF-8 detection, should perform rather instantaneous.
+- The backward compatibility with Chardet has been greatly improved. The legacy detect function returns an identical charset name whenever possible.
+- The detection mechanism has been slightly improved, now Turkish content is detected correctly (most of the time)
+- The program has been rewritten to ease the readability and maintainability. (+Using static typing)+
+- utf_7 detection has been reinstated.
+
+### Removed
+- This package no longer require anything when used with Python 3.5 (Dropped cached_property)
+- Removed support for these languages: Catalan, Esperanto, Kazakh, Baque, VolapΓΌk, Azeri, Galician, Nynorsk, Macedonian, and Serbocroatian.
+- The exception hook on UnicodeDecodeError has been removed.
+
+### Deprecated
+- Methods coherence_non_latin, w_counter, chaos_secondary_pass of the class CharsetMatch are now deprecated and scheduled for removal in v3.0
+
+### Fixed
+- The CLI output used the relative path of the file(s). Should be absolute.
+
+## [1.4.1](https://github.com/Ousret/charset_normalizer/compare/1.4.0...1.4.1) (2021-05-28)
+### Fixed
+- Logger configuration/usage no longer conflict with others (PR #44)
+
+## [1.4.0](https://github.com/Ousret/charset_normalizer/compare/1.3.9...1.4.0) (2021-05-21)
+### Removed
+- Using standard logging instead of using the package loguru.
+- Dropping nose test framework in favor of the maintained pytest.
+- Choose to not use dragonmapper package to help with gibberish Chinese/CJK text.
+- Require cached_property only for Python 3.5 due to constraint. Dropping for every other interpreter version.
+- Stop support for UTF-7 that does not contain a SIG.
+- Dropping PrettyTable, replaced with pure JSON output in CLI.
+
+### Fixed
+- BOM marker in a CharsetNormalizerMatch instance could be False in rare cases even if obviously present. Due to the sub-match factoring process.
+- Not searching properly for the BOM when trying utf32/16 parent codec.
+
+### Changed
+- Improving the package final size by compressing frequencies.json.
+- Huge improvement over the larges payload.
+
+### Added
+- CLI now produces JSON consumable output.
+- Return ASCII if given sequences fit. Given reasonable confidence.
+
+## [1.3.9](https://github.com/Ousret/charset_normalizer/compare/1.3.8...1.3.9) (2021-05-13)
+
+### Fixed
+- In some very rare cases, you may end up getting encode/decode errors due to a bad bytes payload (PR #40)
+
+## [1.3.8](https://github.com/Ousret/charset_normalizer/compare/1.3.7...1.3.8) (2021-05-12)
+
+### Fixed
+- Empty given payload for detection may cause an exception if trying to access the `alphabets` property. (PR #39)
+
+## [1.3.7](https://github.com/Ousret/charset_normalizer/compare/1.3.6...1.3.7) (2021-05-12)
+
+### Fixed
+- The legacy detect function should return UTF-8-SIG if sig is present in the payload. (PR #38)
+
+## [1.3.6](https://github.com/Ousret/charset_normalizer/compare/1.3.5...1.3.6) (2021-02-09)
+
+### Changed
+- Amend the previous release to allow prettytable 2.0 (PR #35)
+
+## [1.3.5](https://github.com/Ousret/charset_normalizer/compare/1.3.4...1.3.5) (2021-02-08)
+
+### Fixed
+- Fix error while using the package with a python pre-release interpreter (PR #33)
+
+### Changed
+- Dependencies refactoring, constraints revised.
+
+### Added
+- Add python 3.9 and 3.10 to the supported interpreters
+
+MIT License
+
+Copyright (c) 2019 TAHRI Ahmed R.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/parrot/lib/python3.10/site-packages/charset_normalizer-3.3.2.dist-info/RECORD b/parrot/lib/python3.10/site-packages/charset_normalizer-3.3.2.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..b887d034def6117281d01316aee8b0ecacdd71a2
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/charset_normalizer-3.3.2.dist-info/RECORD
@@ -0,0 +1,36 @@
+../../../bin/normalizer,sha256=gmkYfJ990pdRvXncZz-r9UkVQvFeTmea_7eWafR4r-s,245
+charset_normalizer-3.3.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+charset_normalizer-3.3.2.dist-info/LICENSE,sha256=6zGgxaT7Cbik4yBV0lweX5w1iidS_vPNcgIT0cz-4kE,1070
+charset_normalizer-3.3.2.dist-info/METADATA,sha256=cfLhl5A6SI-F0oclm8w8ux9wshL1nipdeCdVnYb4AaA,33550
+charset_normalizer-3.3.2.dist-info/RECORD,,
+charset_normalizer-3.3.2.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+charset_normalizer-3.3.2.dist-info/WHEEL,sha256=cD39NF6a3hkhaWoPQJng7gnGZRIfQsUCtwcedITCPtg,152
+charset_normalizer-3.3.2.dist-info/entry_points.txt,sha256=ADSTKrkXZ3hhdOVFi6DcUEHQRS0xfxDIE_pEz4wLIXA,65
+charset_normalizer-3.3.2.dist-info/top_level.txt,sha256=7ASyzePr8_xuZWJsnqJjIBtyV8vhEo0wBCv1MPRRi3Q,19
+charset_normalizer/__init__.py,sha256=UzI3xC8PhmcLRMzSgPb6minTmRq0kWznnCBJ8ZCc2XI,1577
+charset_normalizer/__main__.py,sha256=JxY8bleaENOFlLRb9HfoeZCzAMnn2A1oGR5Xm2eyqg0,73
+charset_normalizer/__pycache__/__init__.cpython-310.pyc,,
+charset_normalizer/__pycache__/__main__.cpython-310.pyc,,
+charset_normalizer/__pycache__/api.cpython-310.pyc,,
+charset_normalizer/__pycache__/cd.cpython-310.pyc,,
+charset_normalizer/__pycache__/constant.cpython-310.pyc,,
+charset_normalizer/__pycache__/legacy.cpython-310.pyc,,
+charset_normalizer/__pycache__/md.cpython-310.pyc,,
+charset_normalizer/__pycache__/models.cpython-310.pyc,,
+charset_normalizer/__pycache__/utils.cpython-310.pyc,,
+charset_normalizer/__pycache__/version.cpython-310.pyc,,
+charset_normalizer/api.py,sha256=WOlWjy6wT8SeMYFpaGbXZFN1TMXa-s8vZYfkL4G29iQ,21097
+charset_normalizer/cd.py,sha256=xwZliZcTQFA3jU0c00PRiu9MNxXTFxQkFLWmMW24ZzI,12560
+charset_normalizer/cli/__init__.py,sha256=D5ERp8P62llm2FuoMzydZ7d9rs8cvvLXqE-1_6oViPc,100
+charset_normalizer/cli/__main__.py,sha256=2F-xURZJzo063Ye-2RLJ2wcmURpbKeAzKwpiws65dAs,9744
+charset_normalizer/cli/__pycache__/__init__.cpython-310.pyc,,
+charset_normalizer/cli/__pycache__/__main__.cpython-310.pyc,,
+charset_normalizer/constant.py,sha256=p0IsOVcEbPWYPOdWhnhRbjK1YVBy6fs05C5vKC-zoxU,40481
+charset_normalizer/legacy.py,sha256=T-QuVMsMeDiQEk8WSszMrzVJg_14AMeSkmHdRYhdl1k,2071
+charset_normalizer/md.cpython-310-x86_64-linux-gnu.so,sha256=Y7QSLD5QLoSFAWys0-tL7R6QB7oi5864zM6zr7RWek4,16064
+charset_normalizer/md.py,sha256=NkSuVLK13_a8c7BxZ4cGIQ5vOtGIWOdh22WZEvjp-7U,19624
+charset_normalizer/md__mypyc.cpython-310-x86_64-linux-gnu.so,sha256=y2N-LgwRp7TCdgRqsmIM8UvKeavC0t8kx_hdRvaSfcY,268472
+charset_normalizer/models.py,sha256=I5i0s4aKCCgLPY2tUY3pwkgFA-BUbbNxQ7hVkVTt62s,11624
+charset_normalizer/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+charset_normalizer/utils.py,sha256=teiosMqzKjXyAHXnGdjSBOgnBZwx-SkBbCLrx0UXy8M,11894
+charset_normalizer/version.py,sha256=iHKUfHD3kDRSyrh_BN2ojh43TA5-UZQjvbVIEFfpHDs,79
diff --git a/parrot/lib/python3.10/site-packages/charset_normalizer-3.3.2.dist-info/REQUESTED b/parrot/lib/python3.10/site-packages/charset_normalizer-3.3.2.dist-info/REQUESTED
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/parrot/lib/python3.10/site-packages/charset_normalizer-3.3.2.dist-info/WHEEL b/parrot/lib/python3.10/site-packages/charset_normalizer-3.3.2.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..7b52c3f3e667e03ca4b2a8b53a94655a796beafc
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/charset_normalizer-3.3.2.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.41.2)
+Root-Is-Purelib: false
+Tag: cp310-cp310-manylinux_2_17_x86_64
+Tag: cp310-cp310-manylinux2014_x86_64
+
diff --git a/parrot/lib/python3.10/site-packages/charset_normalizer-3.3.2.dist-info/top_level.txt b/parrot/lib/python3.10/site-packages/charset_normalizer-3.3.2.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..66958f0a069d7aea7939bed40b9197608e93b243
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/charset_normalizer-3.3.2.dist-info/top_level.txt
@@ -0,0 +1 @@
+charset_normalizer
diff --git a/parrot/lib/python3.10/site-packages/fsspec/__init__.py b/parrot/lib/python3.10/site-packages/fsspec/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d7af775f77cd67734aebd25ce4e051be87e64fa8
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/fsspec/__init__.py
@@ -0,0 +1,69 @@
+from importlib.metadata import entry_points
+
+from . import caching
+from ._version import __version__ # noqa: F401
+from .callbacks import Callback
+from .compression import available_compressions
+from .core import get_fs_token_paths, open, open_files, open_local, url_to_fs
+from .exceptions import FSTimeoutError
+from .mapping import FSMap, get_mapper
+from .registry import (
+ available_protocols,
+ filesystem,
+ get_filesystem_class,
+ register_implementation,
+ registry,
+)
+from .spec import AbstractFileSystem
+
+__all__ = [
+ "AbstractFileSystem",
+ "FSTimeoutError",
+ "FSMap",
+ "filesystem",
+ "register_implementation",
+ "get_filesystem_class",
+ "get_fs_token_paths",
+ "get_mapper",
+ "open",
+ "open_files",
+ "open_local",
+ "registry",
+ "caching",
+ "Callback",
+ "available_protocols",
+ "available_compressions",
+ "url_to_fs",
+]
+
+
+def process_entries():
+ if entry_points is not None:
+ try:
+ eps = entry_points()
+ except TypeError:
+ pass # importlib-metadata < 0.8
+ else:
+ if hasattr(eps, "select"): # Python 3.10+ / importlib_metadata >= 3.9.0
+ specs = eps.select(group="fsspec.specs")
+ else:
+ specs = eps.get("fsspec.specs", [])
+ registered_names = {}
+ for spec in specs:
+ err_msg = f"Unable to load filesystem from {spec}"
+ name = spec.name
+ if name in registered_names:
+ continue
+ registered_names[name] = True
+ register_implementation(
+ name,
+ spec.value.replace(":", "."),
+ errtxt=err_msg,
+ # We take our implementations as the ones to overload with if
+ # for some reason we encounter some, may be the same, already
+ # registered
+ clobber=True,
+ )
+
+
+process_entries()
diff --git a/parrot/lib/python3.10/site-packages/fsspec/_version.py b/parrot/lib/python3.10/site-packages/fsspec/_version.py
new file mode 100644
index 0000000000000000000000000000000000000000..2b84bd68442028bf43b66d524065b76693b244cd
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/fsspec/_version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+ from typing import Tuple, Union
+ VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+ VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '2024.6.1'
+__version_tuple__ = version_tuple = (2024, 6, 1)
diff --git a/parrot/lib/python3.10/site-packages/fsspec/archive.py b/parrot/lib/python3.10/site-packages/fsspec/archive.py
new file mode 100644
index 0000000000000000000000000000000000000000..f466780fc802d6aa79be02a2af3424c051503708
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/fsspec/archive.py
@@ -0,0 +1,73 @@
+from fsspec import AbstractFileSystem
+from fsspec.utils import tokenize
+
+
+class AbstractArchiveFileSystem(AbstractFileSystem):
+ """
+ A generic superclass for implementing Archive-based filesystems.
+
+ Currently, it is shared amongst
+ :class:`~fsspec.implementations.zip.ZipFileSystem`,
+ :class:`~fsspec.implementations.libarchive.LibArchiveFileSystem` and
+ :class:`~fsspec.implementations.tar.TarFileSystem`.
+ """
+
+ def __str__(self):
+ return f""
+
+ __repr__ = __str__
+
+ def ukey(self, path):
+ return tokenize(path, self.fo, self.protocol)
+
+ def _all_dirnames(self, paths):
+ """Returns *all* directory names for each path in paths, including intermediate
+ ones.
+
+ Parameters
+ ----------
+ paths: Iterable of path strings
+ """
+ if len(paths) == 0:
+ return set()
+
+ dirnames = {self._parent(path) for path in paths} - {self.root_marker}
+ return dirnames | self._all_dirnames(dirnames)
+
+ def info(self, path, **kwargs):
+ self._get_dirs()
+ path = self._strip_protocol(path)
+ if path in {"", "/"} and self.dir_cache:
+ return {"name": "", "type": "directory", "size": 0}
+ if path in self.dir_cache:
+ return self.dir_cache[path]
+ elif path + "/" in self.dir_cache:
+ return self.dir_cache[path + "/"]
+ else:
+ raise FileNotFoundError(path)
+
+ def ls(self, path, detail=True, **kwargs):
+ self._get_dirs()
+ paths = {}
+ for p, f in self.dir_cache.items():
+ p = p.rstrip("/")
+ if "/" in p:
+ root = p.rsplit("/", 1)[0]
+ else:
+ root = ""
+ if root == path.rstrip("/"):
+ paths[p] = f
+ elif all(
+ (a == b)
+ for a, b in zip(path.split("/"), [""] + p.strip("/").split("/"))
+ ):
+ # root directory entry
+ ppath = p.rstrip("/").split("/", 1)[0]
+ if ppath not in paths:
+ out = {"name": ppath, "size": 0, "type": "directory"}
+ paths[ppath] = out
+ if detail:
+ out = sorted(paths.values(), key=lambda _: _["name"])
+ return out
+ else:
+ return sorted(paths)
diff --git a/parrot/lib/python3.10/site-packages/fsspec/asyn.py b/parrot/lib/python3.10/site-packages/fsspec/asyn.py
new file mode 100644
index 0000000000000000000000000000000000000000..a040efc4bba984d27b132e961f8245c1ec11721d
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/fsspec/asyn.py
@@ -0,0 +1,1096 @@
+import asyncio
+import asyncio.events
+import functools
+import inspect
+import io
+import numbers
+import os
+import re
+import threading
+from contextlib import contextmanager
+from glob import has_magic
+from typing import TYPE_CHECKING, Iterable
+
+from .callbacks import DEFAULT_CALLBACK
+from .exceptions import FSTimeoutError
+from .implementations.local import LocalFileSystem, make_path_posix, trailing_sep
+from .spec import AbstractBufferedFile, AbstractFileSystem
+from .utils import glob_translate, is_exception, other_paths
+
+private = re.compile("_[^_]")
+iothread = [None] # dedicated fsspec IO thread
+loop = [None] # global event loop for any non-async instance
+_lock = None # global lock placeholder
+get_running_loop = asyncio.get_running_loop
+
+
+def get_lock():
+ """Allocate or return a threading lock.
+
+ The lock is allocated on first use to allow setting one lock per forked process.
+ """
+ global _lock
+ if not _lock:
+ _lock = threading.Lock()
+ return _lock
+
+
+def reset_lock():
+ """Reset the global lock.
+
+ This should be called only on the init of a forked process to reset the lock to
+ None, enabling the new forked process to get a new lock.
+ """
+ global _lock
+
+ iothread[0] = None
+ loop[0] = None
+ _lock = None
+
+
+async def _runner(event, coro, result, timeout=None):
+ timeout = timeout if timeout else None # convert 0 or 0.0 to None
+ if timeout is not None:
+ coro = asyncio.wait_for(coro, timeout=timeout)
+ try:
+ result[0] = await coro
+ except Exception as ex:
+ result[0] = ex
+ finally:
+ event.set()
+
+
+def sync(loop, func, *args, timeout=None, **kwargs):
+ """
+ Make loop run coroutine until it returns. Runs in other thread
+
+ Examples
+ --------
+ >>> fsspec.asyn.sync(fsspec.asyn.get_loop(), func, *args,
+ timeout=timeout, **kwargs)
+ """
+ timeout = timeout if timeout else None # convert 0 or 0.0 to None
+ # NB: if the loop is not running *yet*, it is OK to submit work
+ # and we will wait for it
+ if loop is None or loop.is_closed():
+ raise RuntimeError("Loop is not running")
+ try:
+ loop0 = asyncio.events.get_running_loop()
+ if loop0 is loop:
+ raise NotImplementedError("Calling sync() from within a running loop")
+ except NotImplementedError:
+ raise
+ except RuntimeError:
+ pass
+ coro = func(*args, **kwargs)
+ result = [None]
+ event = threading.Event()
+ asyncio.run_coroutine_threadsafe(_runner(event, coro, result, timeout), loop)
+ while True:
+ # this loops allows thread to get interrupted
+ if event.wait(1):
+ break
+ if timeout is not None:
+ timeout -= 1
+ if timeout < 0:
+ raise FSTimeoutError
+
+ return_result = result[0]
+ if isinstance(return_result, asyncio.TimeoutError):
+ # suppress asyncio.TimeoutError, raise FSTimeoutError
+ raise FSTimeoutError from return_result
+ elif isinstance(return_result, BaseException):
+ raise return_result
+ else:
+ return return_result
+
+
+def sync_wrapper(func, obj=None):
+ """Given a function, make so can be called in blocking contexts
+
+ Leave obj=None if defining within a class. Pass the instance if attaching
+ as an attribute of the instance.
+ """
+
+ @functools.wraps(func)
+ def wrapper(*args, **kwargs):
+ self = obj or args[0]
+ return sync(self.loop, func, *args, **kwargs)
+
+ return wrapper
+
+
+@contextmanager
+def _selector_policy():
+ original_policy = asyncio.get_event_loop_policy()
+ try:
+ if os.name == "nt" and hasattr(asyncio, "WindowsSelectorEventLoopPolicy"):
+ asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+
+ yield
+ finally:
+ asyncio.set_event_loop_policy(original_policy)
+
+
+def get_loop():
+ """Create or return the default fsspec IO loop
+
+ The loop will be running on a separate thread.
+ """
+ if loop[0] is None:
+ with get_lock():
+ # repeat the check just in case the loop got filled between the
+ # previous two calls from another thread
+ if loop[0] is None:
+ with _selector_policy():
+ loop[0] = asyncio.new_event_loop()
+ th = threading.Thread(target=loop[0].run_forever, name="fsspecIO")
+ th.daemon = True
+ th.start()
+ iothread[0] = th
+ return loop[0]
+
+
+if TYPE_CHECKING:
+ import resource
+
+ ResourceError = resource.error
+else:
+ try:
+ import resource
+ except ImportError:
+ resource = None
+ ResourceError = OSError
+ else:
+ ResourceError = getattr(resource, "error", OSError)
+
+_DEFAULT_BATCH_SIZE = 128
+_NOFILES_DEFAULT_BATCH_SIZE = 1280
+
+
+def _get_batch_size(nofiles=False):
+ from fsspec.config import conf
+
+ if nofiles:
+ if "nofiles_gather_batch_size" in conf:
+ return conf["nofiles_gather_batch_size"]
+ else:
+ if "gather_batch_size" in conf:
+ return conf["gather_batch_size"]
+ if nofiles:
+ return _NOFILES_DEFAULT_BATCH_SIZE
+ if resource is None:
+ return _DEFAULT_BATCH_SIZE
+
+ try:
+ soft_limit, _ = resource.getrlimit(resource.RLIMIT_NOFILE)
+ except (ImportError, ValueError, ResourceError):
+ return _DEFAULT_BATCH_SIZE
+
+ if soft_limit == resource.RLIM_INFINITY:
+ return -1
+ else:
+ return soft_limit // 8
+
+
+def running_async() -> bool:
+ """Being executed by an event loop?"""
+ try:
+ asyncio.get_running_loop()
+ return True
+ except RuntimeError:
+ return False
+
+
+async def _run_coros_in_chunks(
+ coros,
+ batch_size=None,
+ callback=DEFAULT_CALLBACK,
+ timeout=None,
+ return_exceptions=False,
+ nofiles=False,
+):
+ """Run the given coroutines in chunks.
+
+ Parameters
+ ----------
+ coros: list of coroutines to run
+ batch_size: int or None
+ Number of coroutines to submit/wait on simultaneously.
+ If -1, then it will not be any throttling. If
+ None, it will be inferred from _get_batch_size()
+ callback: fsspec.callbacks.Callback instance
+ Gets a relative_update when each coroutine completes
+ timeout: number or None
+ If given, each coroutine times out after this time. Note that, since
+ there are multiple batches, the total run time of this function will in
+ general be longer
+ return_exceptions: bool
+ Same meaning as in asyncio.gather
+ nofiles: bool
+ If inferring the batch_size, does this operation involve local files?
+ If yes, you normally expect smaller batches.
+ """
+
+ if batch_size is None:
+ batch_size = _get_batch_size(nofiles=nofiles)
+
+ if batch_size == -1:
+ batch_size = len(coros)
+
+ assert batch_size > 0
+
+ async def _run_coro(coro, i):
+ try:
+ return await asyncio.wait_for(coro, timeout=timeout), i
+ except Exception as e:
+ if not return_exceptions:
+ raise
+ return e, i
+ finally:
+ callback.relative_update(1)
+
+ i = 0
+ n = len(coros)
+ results = [None] * n
+ pending = set()
+
+ while pending or i < n:
+ while len(pending) < batch_size and i < n:
+ pending.add(asyncio.ensure_future(_run_coro(coros[i], i)))
+ i += 1
+
+ if not pending:
+ break
+
+ done, pending = await asyncio.wait(pending, return_when=asyncio.FIRST_COMPLETED)
+ while done:
+ result, k = await done.pop()
+ results[k] = result
+
+ return results
+
+
+# these methods should be implemented as async by any async-able backend
+async_methods = [
+ "_ls",
+ "_cat_file",
+ "_get_file",
+ "_put_file",
+ "_rm_file",
+ "_cp_file",
+ "_pipe_file",
+ "_expand_path",
+ "_info",
+ "_isfile",
+ "_isdir",
+ "_exists",
+ "_walk",
+ "_glob",
+ "_find",
+ "_du",
+ "_size",
+ "_mkdir",
+ "_makedirs",
+]
+
+
+class AsyncFileSystem(AbstractFileSystem):
+ """Async file operations, default implementations
+
+ Passes bulk operations to asyncio.gather for concurrent operation.
+
+ Implementations that have concurrent batch operations and/or async methods
+ should inherit from this class instead of AbstractFileSystem. Docstrings are
+ copied from the un-underscored method in AbstractFileSystem, if not given.
+ """
+
+ # note that methods do not have docstring here; they will be copied
+ # for _* methods and inferred for overridden methods.
+
+ async_impl = True
+ mirror_sync_methods = True
+ disable_throttling = False
+
+ def __init__(self, *args, asynchronous=False, loop=None, batch_size=None, **kwargs):
+ self.asynchronous = asynchronous
+ self._pid = os.getpid()
+ if not asynchronous:
+ self._loop = loop or get_loop()
+ else:
+ self._loop = None
+ self.batch_size = batch_size
+ super().__init__(*args, **kwargs)
+
+ @property
+ def loop(self):
+ if self._pid != os.getpid():
+ raise RuntimeError("This class is not fork-safe")
+ return self._loop
+
+ async def _rm_file(self, path, **kwargs):
+ raise NotImplementedError
+
+ async def _rm(self, path, recursive=False, batch_size=None, **kwargs):
+ # TODO: implement on_error
+ batch_size = batch_size or self.batch_size
+ path = await self._expand_path(path, recursive=recursive)
+ return await _run_coros_in_chunks(
+ [self._rm_file(p, **kwargs) for p in reversed(path)],
+ batch_size=batch_size,
+ nofiles=True,
+ )
+
+ async def _cp_file(self, path1, path2, **kwargs):
+ raise NotImplementedError
+
+ async def _copy(
+ self,
+ path1,
+ path2,
+ recursive=False,
+ on_error=None,
+ maxdepth=None,
+ batch_size=None,
+ **kwargs,
+ ):
+ if on_error is None and recursive:
+ on_error = "ignore"
+ elif on_error is None:
+ on_error = "raise"
+
+ if isinstance(path1, list) and isinstance(path2, list):
+ # No need to expand paths when both source and destination
+ # are provided as lists
+ paths1 = path1
+ paths2 = path2
+ else:
+ source_is_str = isinstance(path1, str)
+ paths1 = await self._expand_path(
+ path1, maxdepth=maxdepth, recursive=recursive
+ )
+ if source_is_str and (not recursive or maxdepth is not None):
+ # Non-recursive glob does not copy directories
+ paths1 = [
+ p for p in paths1 if not (trailing_sep(p) or await self._isdir(p))
+ ]
+ if not paths1:
+ return
+
+ source_is_file = len(paths1) == 1
+ dest_is_dir = isinstance(path2, str) and (
+ trailing_sep(path2) or await self._isdir(path2)
+ )
+
+ exists = source_is_str and (
+ (has_magic(path1) and source_is_file)
+ or (not has_magic(path1) and dest_is_dir and not trailing_sep(path1))
+ )
+ paths2 = other_paths(
+ paths1,
+ path2,
+ exists=exists,
+ flatten=not source_is_str,
+ )
+
+ batch_size = batch_size or self.batch_size
+ coros = [self._cp_file(p1, p2, **kwargs) for p1, p2 in zip(paths1, paths2)]
+ result = await _run_coros_in_chunks(
+ coros, batch_size=batch_size, return_exceptions=True, nofiles=True
+ )
+
+ for ex in filter(is_exception, result):
+ if on_error == "ignore" and isinstance(ex, FileNotFoundError):
+ continue
+ raise ex
+
+ async def _pipe_file(self, path, value, **kwargs):
+ raise NotImplementedError
+
+ async def _pipe(self, path, value=None, batch_size=None, **kwargs):
+ if isinstance(path, str):
+ path = {path: value}
+ batch_size = batch_size or self.batch_size
+ return await _run_coros_in_chunks(
+ [self._pipe_file(k, v, **kwargs) for k, v in path.items()],
+ batch_size=batch_size,
+ nofiles=True,
+ )
+
+ async def _process_limits(self, url, start, end):
+ """Helper for "Range"-based _cat_file"""
+ size = None
+ suff = False
+ if start is not None and start < 0:
+ # if start is negative and end None, end is the "suffix length"
+ if end is None:
+ end = -start
+ start = ""
+ suff = True
+ else:
+ size = size or (await self._info(url))["size"]
+ start = size + start
+ elif start is None:
+ start = 0
+ if not suff:
+ if end is not None and end < 0:
+ if start is not None:
+ size = size or (await self._info(url))["size"]
+ end = size + end
+ elif end is None:
+ end = ""
+ if isinstance(end, numbers.Integral):
+ end -= 1 # bytes range is inclusive
+ return f"bytes={start}-{end}"
+
+ async def _cat_file(self, path, start=None, end=None, **kwargs):
+ raise NotImplementedError
+
+ async def _cat(
+ self, path, recursive=False, on_error="raise", batch_size=None, **kwargs
+ ):
+ paths = await self._expand_path(path, recursive=recursive)
+ coros = [self._cat_file(path, **kwargs) for path in paths]
+ batch_size = batch_size or self.batch_size
+ out = await _run_coros_in_chunks(
+ coros, batch_size=batch_size, nofiles=True, return_exceptions=True
+ )
+ if on_error == "raise":
+ ex = next(filter(is_exception, out), False)
+ if ex:
+ raise ex
+ if (
+ len(paths) > 1
+ or isinstance(path, list)
+ or paths[0] != self._strip_protocol(path)
+ ):
+ return {
+ k: v
+ for k, v in zip(paths, out)
+ if on_error != "omit" or not is_exception(v)
+ }
+ else:
+ return out[0]
+
+ async def _cat_ranges(
+ self,
+ paths,
+ starts,
+ ends,
+ max_gap=None,
+ batch_size=None,
+ on_error="return",
+ **kwargs,
+ ):
+ """Get the contents of byte ranges from one or more files
+
+ Parameters
+ ----------
+ paths: list
+ A list of of filepaths on this filesystems
+ starts, ends: int or list
+ Bytes limits of the read. If using a single int, the same value will be
+ used to read all the specified files.
+ """
+ # TODO: on_error
+ if max_gap is not None:
+ # use utils.merge_offset_ranges
+ raise NotImplementedError
+ if not isinstance(paths, list):
+ raise TypeError
+ if not isinstance(starts, Iterable):
+ starts = [starts] * len(paths)
+ if not isinstance(ends, Iterable):
+ ends = [ends] * len(paths)
+ if len(starts) != len(paths) or len(ends) != len(paths):
+ raise ValueError
+ coros = [
+ self._cat_file(p, start=s, end=e, **kwargs)
+ for p, s, e in zip(paths, starts, ends)
+ ]
+ batch_size = batch_size or self.batch_size
+ return await _run_coros_in_chunks(
+ coros, batch_size=batch_size, nofiles=True, return_exceptions=True
+ )
+
+ async def _put_file(self, lpath, rpath, **kwargs):
+ raise NotImplementedError
+
+ async def _put(
+ self,
+ lpath,
+ rpath,
+ recursive=False,
+ callback=DEFAULT_CALLBACK,
+ batch_size=None,
+ maxdepth=None,
+ **kwargs,
+ ):
+ """Copy file(s) from local.
+
+ Copies a specific file or tree of files (if recursive=True). If rpath
+ ends with a "/", it will be assumed to be a directory, and target files
+ will go within.
+
+ The put_file method will be called concurrently on a batch of files. The
+ batch_size option can configure the amount of futures that can be executed
+ at the same time. If it is -1, then all the files will be uploaded concurrently.
+ The default can be set for this instance by passing "batch_size" in the
+ constructor, or for all instances by setting the "gather_batch_size" key
+ in ``fsspec.config.conf``, falling back to 1/8th of the system limit .
+ """
+ if isinstance(lpath, list) and isinstance(rpath, list):
+ # No need to expand paths when both source and destination
+ # are provided as lists
+ rpaths = rpath
+ lpaths = lpath
+ else:
+ source_is_str = isinstance(lpath, str)
+ if source_is_str:
+ lpath = make_path_posix(lpath)
+ fs = LocalFileSystem()
+ lpaths = fs.expand_path(lpath, recursive=recursive, maxdepth=maxdepth)
+ if source_is_str and (not recursive or maxdepth is not None):
+ # Non-recursive glob does not copy directories
+ lpaths = [p for p in lpaths if not (trailing_sep(p) or fs.isdir(p))]
+ if not lpaths:
+ return
+
+ source_is_file = len(lpaths) == 1
+ dest_is_dir = isinstance(rpath, str) and (
+ trailing_sep(rpath) or await self._isdir(rpath)
+ )
+
+ rpath = self._strip_protocol(rpath)
+ exists = source_is_str and (
+ (has_magic(lpath) and source_is_file)
+ or (not has_magic(lpath) and dest_is_dir and not trailing_sep(lpath))
+ )
+ rpaths = other_paths(
+ lpaths,
+ rpath,
+ exists=exists,
+ flatten=not source_is_str,
+ )
+
+ is_dir = {l: os.path.isdir(l) for l in lpaths}
+ rdirs = [r for l, r in zip(lpaths, rpaths) if is_dir[l]]
+ file_pairs = [(l, r) for l, r in zip(lpaths, rpaths) if not is_dir[l]]
+
+ await asyncio.gather(*[self._makedirs(d, exist_ok=True) for d in rdirs])
+ batch_size = batch_size or self.batch_size
+
+ coros = []
+ callback.set_size(len(file_pairs))
+ for lfile, rfile in file_pairs:
+ put_file = callback.branch_coro(self._put_file)
+ coros.append(put_file(lfile, rfile, **kwargs))
+
+ return await _run_coros_in_chunks(
+ coros, batch_size=batch_size, callback=callback
+ )
+
+ async def _get_file(self, rpath, lpath, **kwargs):
+ raise NotImplementedError
+
+ async def _get(
+ self,
+ rpath,
+ lpath,
+ recursive=False,
+ callback=DEFAULT_CALLBACK,
+ maxdepth=None,
+ **kwargs,
+ ):
+ """Copy file(s) to local.
+
+ Copies a specific file or tree of files (if recursive=True). If lpath
+ ends with a "/", it will be assumed to be a directory, and target files
+ will go within. Can submit a list of paths, which may be glob-patterns
+ and will be expanded.
+
+ The get_file method will be called concurrently on a batch of files. The
+ batch_size option can configure the amount of futures that can be executed
+ at the same time. If it is -1, then all the files will be uploaded concurrently.
+ The default can be set for this instance by passing "batch_size" in the
+ constructor, or for all instances by setting the "gather_batch_size" key
+ in ``fsspec.config.conf``, falling back to 1/8th of the system limit .
+ """
+ if isinstance(lpath, list) and isinstance(rpath, list):
+ # No need to expand paths when both source and destination
+ # are provided as lists
+ rpaths = rpath
+ lpaths = lpath
+ else:
+ source_is_str = isinstance(rpath, str)
+ # First check for rpath trailing slash as _strip_protocol removes it.
+ source_not_trailing_sep = source_is_str and not trailing_sep(rpath)
+ rpath = self._strip_protocol(rpath)
+ rpaths = await self._expand_path(
+ rpath, recursive=recursive, maxdepth=maxdepth
+ )
+ if source_is_str and (not recursive or maxdepth is not None):
+ # Non-recursive glob does not copy directories
+ rpaths = [
+ p for p in rpaths if not (trailing_sep(p) or await self._isdir(p))
+ ]
+ if not rpaths:
+ return
+
+ lpath = make_path_posix(lpath)
+ source_is_file = len(rpaths) == 1
+ dest_is_dir = isinstance(lpath, str) and (
+ trailing_sep(lpath) or LocalFileSystem().isdir(lpath)
+ )
+
+ exists = source_is_str and (
+ (has_magic(rpath) and source_is_file)
+ or (not has_magic(rpath) and dest_is_dir and source_not_trailing_sep)
+ )
+ lpaths = other_paths(
+ rpaths,
+ lpath,
+ exists=exists,
+ flatten=not source_is_str,
+ )
+
+ [os.makedirs(os.path.dirname(lp), exist_ok=True) for lp in lpaths]
+ batch_size = kwargs.pop("batch_size", self.batch_size)
+
+ coros = []
+ callback.set_size(len(lpaths))
+ for lpath, rpath in zip(lpaths, rpaths):
+ get_file = callback.branch_coro(self._get_file)
+ coros.append(get_file(rpath, lpath, **kwargs))
+ return await _run_coros_in_chunks(
+ coros, batch_size=batch_size, callback=callback
+ )
+
+ async def _isfile(self, path):
+ try:
+ return (await self._info(path))["type"] == "file"
+ except: # noqa: E722
+ return False
+
+ async def _isdir(self, path):
+ try:
+ return (await self._info(path))["type"] == "directory"
+ except OSError:
+ return False
+
+ async def _size(self, path):
+ return (await self._info(path)).get("size", None)
+
+ async def _sizes(self, paths, batch_size=None):
+ batch_size = batch_size or self.batch_size
+ return await _run_coros_in_chunks(
+ [self._size(p) for p in paths], batch_size=batch_size
+ )
+
+ async def _exists(self, path, **kwargs):
+ try:
+ await self._info(path, **kwargs)
+ return True
+ except FileNotFoundError:
+ return False
+
+ async def _info(self, path, **kwargs):
+ raise NotImplementedError
+
+ async def _ls(self, path, detail=True, **kwargs):
+ raise NotImplementedError
+
+ async def _walk(self, path, maxdepth=None, on_error="omit", **kwargs):
+ if maxdepth is not None and maxdepth < 1:
+ raise ValueError("maxdepth must be at least 1")
+
+ path = self._strip_protocol(path)
+ full_dirs = {}
+ dirs = {}
+ files = {}
+
+ detail = kwargs.pop("detail", False)
+ try:
+ listing = await self._ls(path, detail=True, **kwargs)
+ except (FileNotFoundError, OSError) as e:
+ if on_error == "raise":
+ raise
+ elif callable(on_error):
+ on_error(e)
+ if detail:
+ yield path, {}, {}
+ else:
+ yield path, [], []
+ return
+
+ for info in listing:
+ # each info name must be at least [path]/part , but here
+ # we check also for names like [path]/part/
+ pathname = info["name"].rstrip("/")
+ name = pathname.rsplit("/", 1)[-1]
+ if info["type"] == "directory" and pathname != path:
+ # do not include "self" path
+ full_dirs[name] = pathname
+ dirs[name] = info
+ elif pathname == path:
+ # file-like with same name as give path
+ files[""] = info
+ else:
+ files[name] = info
+
+ if detail:
+ yield path, dirs, files
+ else:
+ yield path, list(dirs), list(files)
+
+ if maxdepth is not None:
+ maxdepth -= 1
+ if maxdepth < 1:
+ return
+
+ for d in dirs:
+ async for _ in self._walk(
+ full_dirs[d], maxdepth=maxdepth, detail=detail, **kwargs
+ ):
+ yield _
+
+ async def _glob(self, path, maxdepth=None, **kwargs):
+ if maxdepth is not None and maxdepth < 1:
+ raise ValueError("maxdepth must be at least 1")
+
+ import re
+
+ seps = (os.path.sep, os.path.altsep) if os.path.altsep else (os.path.sep,)
+ ends_with_sep = path.endswith(seps) # _strip_protocol strips trailing slash
+ path = self._strip_protocol(path)
+ append_slash_to_dirname = ends_with_sep or path.endswith(
+ tuple(sep + "**" for sep in seps)
+ )
+ idx_star = path.find("*") if path.find("*") >= 0 else len(path)
+ idx_qmark = path.find("?") if path.find("?") >= 0 else len(path)
+ idx_brace = path.find("[") if path.find("[") >= 0 else len(path)
+
+ min_idx = min(idx_star, idx_qmark, idx_brace)
+
+ detail = kwargs.pop("detail", False)
+
+ if not has_magic(path):
+ if await self._exists(path, **kwargs):
+ if not detail:
+ return [path]
+ else:
+ return {path: await self._info(path, **kwargs)}
+ else:
+ if not detail:
+ return [] # glob of non-existent returns empty
+ else:
+ return {}
+ elif "/" in path[:min_idx]:
+ min_idx = path[:min_idx].rindex("/")
+ root = path[: min_idx + 1]
+ depth = path[min_idx + 1 :].count("/") + 1
+ else:
+ root = ""
+ depth = path[min_idx + 1 :].count("/") + 1
+
+ if "**" in path:
+ if maxdepth is not None:
+ idx_double_stars = path.find("**")
+ depth_double_stars = path[idx_double_stars:].count("/") + 1
+ depth = depth - depth_double_stars + maxdepth
+ else:
+ depth = None
+
+ allpaths = await self._find(
+ root, maxdepth=depth, withdirs=True, detail=True, **kwargs
+ )
+
+ pattern = glob_translate(path + ("/" if ends_with_sep else ""))
+ pattern = re.compile(pattern)
+
+ out = {
+ p: info
+ for p, info in sorted(allpaths.items())
+ if pattern.match(
+ (
+ p + "/"
+ if append_slash_to_dirname and info["type"] == "directory"
+ else p
+ )
+ )
+ }
+
+ if detail:
+ return out
+ else:
+ return list(out)
+
+ async def _du(self, path, total=True, maxdepth=None, **kwargs):
+ sizes = {}
+ # async for?
+ for f in await self._find(path, maxdepth=maxdepth, **kwargs):
+ info = await self._info(f)
+ sizes[info["name"]] = info["size"]
+ if total:
+ return sum(sizes.values())
+ else:
+ return sizes
+
+ async def _find(self, path, maxdepth=None, withdirs=False, **kwargs):
+ path = self._strip_protocol(path)
+ out = {}
+ detail = kwargs.pop("detail", False)
+
+ # Add the root directory if withdirs is requested
+ # This is needed for posix glob compliance
+ if withdirs and path != "" and await self._isdir(path):
+ out[path] = await self._info(path)
+
+ # async for?
+ async for _, dirs, files in self._walk(path, maxdepth, detail=True, **kwargs):
+ if withdirs:
+ files.update(dirs)
+ out.update({info["name"]: info for name, info in files.items()})
+ if not out and (await self._isfile(path)):
+ # walk works on directories, but find should also return [path]
+ # when path happens to be a file
+ out[path] = {}
+ names = sorted(out)
+ if not detail:
+ return names
+ else:
+ return {name: out[name] for name in names}
+
+ async def _expand_path(self, path, recursive=False, maxdepth=None):
+ if maxdepth is not None and maxdepth < 1:
+ raise ValueError("maxdepth must be at least 1")
+
+ if isinstance(path, str):
+ out = await self._expand_path([path], recursive, maxdepth)
+ else:
+ out = set()
+ path = [self._strip_protocol(p) for p in path]
+ for p in path: # can gather here
+ if has_magic(p):
+ bit = set(await self._glob(p, maxdepth=maxdepth))
+ out |= bit
+ if recursive:
+ # glob call above expanded one depth so if maxdepth is defined
+ # then decrement it in expand_path call below. If it is zero
+ # after decrementing then avoid expand_path call.
+ if maxdepth is not None and maxdepth <= 1:
+ continue
+ out |= set(
+ await self._expand_path(
+ list(bit),
+ recursive=recursive,
+ maxdepth=maxdepth - 1 if maxdepth is not None else None,
+ )
+ )
+ continue
+ elif recursive:
+ rec = set(await self._find(p, maxdepth=maxdepth, withdirs=True))
+ out |= rec
+ if p not in out and (recursive is False or (await self._exists(p))):
+ # should only check once, for the root
+ out.add(p)
+ if not out:
+ raise FileNotFoundError(path)
+ return sorted(out)
+
+ async def _mkdir(self, path, create_parents=True, **kwargs):
+ pass # not necessary to implement, may not have directories
+
+ async def _makedirs(self, path, exist_ok=False):
+ pass # not necessary to implement, may not have directories
+
+ async def open_async(self, path, mode="rb", **kwargs):
+ if "b" not in mode or kwargs.get("compression"):
+ raise ValueError
+ raise NotImplementedError
+
+
+def mirror_sync_methods(obj):
+ """Populate sync and async methods for obj
+
+ For each method will create a sync version if the name refers to an async method
+ (coroutine) and there is no override in the child class; will create an async
+ method for the corresponding sync method if there is no implementation.
+
+ Uses the methods specified in
+ - async_methods: the set that an implementation is expected to provide
+ - default_async_methods: that can be derived from their sync version in
+ AbstractFileSystem
+ - AsyncFileSystem: async-specific default coroutines
+ """
+ from fsspec import AbstractFileSystem
+
+ for method in async_methods + dir(AsyncFileSystem):
+ if not method.startswith("_"):
+ continue
+ smethod = method[1:]
+ if private.match(method):
+ isco = inspect.iscoroutinefunction(getattr(obj, method, None))
+ unsync = getattr(getattr(obj, smethod, False), "__func__", None)
+ is_default = unsync is getattr(AbstractFileSystem, smethod, "")
+ if isco and is_default:
+ mth = sync_wrapper(getattr(obj, method), obj=obj)
+ setattr(obj, smethod, mth)
+ if not mth.__doc__:
+ mth.__doc__ = getattr(
+ getattr(AbstractFileSystem, smethod, None), "__doc__", ""
+ )
+
+
+class FSSpecCoroutineCancel(Exception):
+ pass
+
+
+def _dump_running_tasks(
+ printout=True, cancel=True, exc=FSSpecCoroutineCancel, with_task=False
+):
+ import traceback
+
+ tasks = [t for t in asyncio.tasks.all_tasks(loop[0]) if not t.done()]
+ if printout:
+ [task.print_stack() for task in tasks]
+ out = [
+ {
+ "locals": task._coro.cr_frame.f_locals,
+ "file": task._coro.cr_frame.f_code.co_filename,
+ "firstline": task._coro.cr_frame.f_code.co_firstlineno,
+ "linelo": task._coro.cr_frame.f_lineno,
+ "stack": traceback.format_stack(task._coro.cr_frame),
+ "task": task if with_task else None,
+ }
+ for task in tasks
+ ]
+ if cancel:
+ for t in tasks:
+ cbs = t._callbacks
+ t.cancel()
+ asyncio.futures.Future.set_exception(t, exc)
+ asyncio.futures.Future.cancel(t)
+ [cb[0](t) for cb in cbs] # cancels any dependent concurrent.futures
+ try:
+ t._coro.throw(exc) # exits coro, unless explicitly handled
+ except exc:
+ pass
+ return out
+
+
+class AbstractAsyncStreamedFile(AbstractBufferedFile):
+ # no read buffering, and always auto-commit
+ # TODO: readahead might still be useful here, but needs async version
+
+ async def read(self, length=-1):
+ """
+ Return data from cache, or fetch pieces as necessary
+
+ Parameters
+ ----------
+ length: int (-1)
+ Number of bytes to read; if <0, all remaining bytes.
+ """
+ length = -1 if length is None else int(length)
+ if self.mode != "rb":
+ raise ValueError("File not in read mode")
+ if length < 0:
+ length = self.size - self.loc
+ if self.closed:
+ raise ValueError("I/O operation on closed file.")
+ if length == 0:
+ # don't even bother calling fetch
+ return b""
+ out = await self._fetch_range(self.loc, self.loc + length)
+ self.loc += len(out)
+ return out
+
+ async def write(self, data):
+ """
+ Write data to buffer.
+
+ Buffer only sent on flush() or if buffer is greater than
+ or equal to blocksize.
+
+ Parameters
+ ----------
+ data: bytes
+ Set of bytes to be written.
+ """
+ if self.mode not in {"wb", "ab"}:
+ raise ValueError("File not in write mode")
+ if self.closed:
+ raise ValueError("I/O operation on closed file.")
+ if self.forced:
+ raise ValueError("This file has been force-flushed, can only close")
+ out = self.buffer.write(data)
+ self.loc += out
+ if self.buffer.tell() >= self.blocksize:
+ await self.flush()
+ return out
+
+ async def close(self):
+ """Close file
+
+ Finalizes writes, discards cache
+ """
+ if getattr(self, "_unclosable", False):
+ return
+ if self.closed:
+ return
+ if self.mode == "rb":
+ self.cache = None
+ else:
+ if not self.forced:
+ await self.flush(force=True)
+
+ if self.fs is not None:
+ self.fs.invalidate_cache(self.path)
+ self.fs.invalidate_cache(self.fs._parent(self.path))
+
+ self.closed = True
+
+ async def flush(self, force=False):
+ if self.closed:
+ raise ValueError("Flush on closed file")
+ if force and self.forced:
+ raise ValueError("Force flush cannot be called more than once")
+ if force:
+ self.forced = True
+
+ if self.mode not in {"wb", "ab"}:
+ # no-op to flush on read-mode
+ return
+
+ if not force and self.buffer.tell() < self.blocksize:
+ # Defer write on small block
+ return
+
+ if self.offset is None:
+ # Initialize a multipart upload
+ self.offset = 0
+ try:
+ await self._initiate_upload()
+ except: # noqa: E722
+ self.closed = True
+ raise
+
+ if await self._upload_chunk(final=force) is not False:
+ self.offset += self.buffer.seek(0, 2)
+ self.buffer = io.BytesIO()
+
+ async def __aenter__(self):
+ return self
+
+ async def __aexit__(self, exc_type, exc_val, exc_tb):
+ await self.close()
+
+ async def _fetch_range(self, start, end):
+ raise NotImplementedError
+
+ async def _initiate_upload(self):
+ pass
+
+ async def _upload_chunk(self, final=False):
+ raise NotImplementedError
diff --git a/parrot/lib/python3.10/site-packages/fsspec/caching.py b/parrot/lib/python3.10/site-packages/fsspec/caching.py
new file mode 100644
index 0000000000000000000000000000000000000000..a3f7a1c9f121b2944e6b63117fa98f1357e22d7f
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/fsspec/caching.py
@@ -0,0 +1,951 @@
+from __future__ import annotations
+
+import collections
+import functools
+import logging
+import math
+import os
+import threading
+import warnings
+from concurrent.futures import Future, ThreadPoolExecutor
+from typing import (
+ TYPE_CHECKING,
+ Any,
+ Callable,
+ ClassVar,
+ Generic,
+ NamedTuple,
+ Optional,
+ OrderedDict,
+ TypeVar,
+)
+
+if TYPE_CHECKING:
+ import mmap
+
+ from typing_extensions import ParamSpec
+
+ P = ParamSpec("P")
+else:
+ P = TypeVar("P")
+
+T = TypeVar("T")
+
+
+logger = logging.getLogger("fsspec")
+
+Fetcher = Callable[[int, int], bytes] # Maps (start, end) to bytes
+
+
+class BaseCache:
+ """Pass-though cache: doesn't keep anything, calls every time
+
+ Acts as base class for other cachers
+
+ Parameters
+ ----------
+ blocksize: int
+ How far to read ahead in numbers of bytes
+ fetcher: func
+ Function of the form f(start, end) which gets bytes from remote as
+ specified
+ size: int
+ How big this file is
+ """
+
+ name: ClassVar[str] = "none"
+
+ def __init__(self, blocksize: int, fetcher: Fetcher, size: int) -> None:
+ self.blocksize = blocksize
+ self.nblocks = 0
+ self.fetcher = fetcher
+ self.size = size
+ self.hit_count = 0
+ self.miss_count = 0
+ # the bytes that we actually requested
+ self.total_requested_bytes = 0
+
+ def _fetch(self, start: int | None, stop: int | None) -> bytes:
+ if start is None:
+ start = 0
+ if stop is None:
+ stop = self.size
+ if start >= self.size or start >= stop:
+ return b""
+ return self.fetcher(start, stop)
+
+ def _reset_stats(self) -> None:
+ """Reset hit and miss counts for a more ganular report e.g. by file."""
+ self.hit_count = 0
+ self.miss_count = 0
+ self.total_requested_bytes = 0
+
+ def _log_stats(self) -> str:
+ """Return a formatted string of the cache statistics."""
+ if self.hit_count == 0 and self.miss_count == 0:
+ # a cache that does nothing, this is for logs only
+ return ""
+ return " , %s: %d hits, %d misses, %d total requested bytes" % (
+ self.name,
+ self.hit_count,
+ self.miss_count,
+ self.total_requested_bytes,
+ )
+
+ def __repr__(self) -> str:
+ # TODO: use rich for better formatting
+ return f"""
+ <{self.__class__.__name__}:
+ block size : {self.blocksize}
+ block count : {self.nblocks}
+ file size : {self.size}
+ cache hits : {self.hit_count}
+ cache misses: {self.miss_count}
+ total requested bytes: {self.total_requested_bytes}>
+ """
+
+
+class MMapCache(BaseCache):
+ """memory-mapped sparse file cache
+
+ Opens temporary file, which is filled blocks-wise when data is requested.
+ Ensure there is enough disc space in the temporary location.
+
+ This cache method might only work on posix
+ """
+
+ name = "mmap"
+
+ def __init__(
+ self,
+ blocksize: int,
+ fetcher: Fetcher,
+ size: int,
+ location: str | None = None,
+ blocks: set[int] | None = None,
+ ) -> None:
+ super().__init__(blocksize, fetcher, size)
+ self.blocks = set() if blocks is None else blocks
+ self.location = location
+ self.cache = self._makefile()
+
+ def _makefile(self) -> mmap.mmap | bytearray:
+ import mmap
+ import tempfile
+
+ if self.size == 0:
+ return bytearray()
+
+ # posix version
+ if self.location is None or not os.path.exists(self.location):
+ if self.location is None:
+ fd = tempfile.TemporaryFile()
+ self.blocks = set()
+ else:
+ fd = open(self.location, "wb+")
+ fd.seek(self.size - 1)
+ fd.write(b"1")
+ fd.flush()
+ else:
+ fd = open(self.location, "r+b")
+
+ return mmap.mmap(fd.fileno(), self.size)
+
+ def _fetch(self, start: int | None, end: int | None) -> bytes:
+ logger.debug(f"MMap cache fetching {start}-{end}")
+ if start is None:
+ start = 0
+ if end is None:
+ end = self.size
+ if start >= self.size or start >= end:
+ return b""
+ start_block = start // self.blocksize
+ end_block = end // self.blocksize
+ need = [i for i in range(start_block, end_block + 1) if i not in self.blocks]
+ hits = [i for i in range(start_block, end_block + 1) if i in self.blocks]
+ self.miss_count += len(need)
+ self.hit_count += len(hits)
+ while need:
+ # TODO: not a for loop so we can consolidate blocks later to
+ # make fewer fetch calls; this could be parallel
+ i = need.pop(0)
+
+ sstart = i * self.blocksize
+ send = min(sstart + self.blocksize, self.size)
+ self.total_requested_bytes += send - sstart
+ logger.debug(f"MMap get block #{i} ({sstart}-{send})")
+ self.cache[sstart:send] = self.fetcher(sstart, send)
+ self.blocks.add(i)
+
+ return self.cache[start:end]
+
+ def __getstate__(self) -> dict[str, Any]:
+ state = self.__dict__.copy()
+ # Remove the unpicklable entries.
+ del state["cache"]
+ return state
+
+ def __setstate__(self, state: dict[str, Any]) -> None:
+ # Restore instance attributes
+ self.__dict__.update(state)
+ self.cache = self._makefile()
+
+
+class ReadAheadCache(BaseCache):
+ """Cache which reads only when we get beyond a block of data
+
+ This is a much simpler version of BytesCache, and does not attempt to
+ fill holes in the cache or keep fragments alive. It is best suited to
+ many small reads in a sequential order (e.g., reading lines from a file).
+ """
+
+ name = "readahead"
+
+ def __init__(self, blocksize: int, fetcher: Fetcher, size: int) -> None:
+ super().__init__(blocksize, fetcher, size)
+ self.cache = b""
+ self.start = 0
+ self.end = 0
+
+ def _fetch(self, start: int | None, end: int | None) -> bytes:
+ if start is None:
+ start = 0
+ if end is None or end > self.size:
+ end = self.size
+ if start >= self.size or start >= end:
+ return b""
+ l = end - start
+ if start >= self.start and end <= self.end:
+ # cache hit
+ self.hit_count += 1
+ return self.cache[start - self.start : end - self.start]
+ elif self.start <= start < self.end:
+ # partial hit
+ self.miss_count += 1
+ part = self.cache[start - self.start :]
+ l -= len(part)
+ start = self.end
+ else:
+ # miss
+ self.miss_count += 1
+ part = b""
+ end = min(self.size, end + self.blocksize)
+ self.total_requested_bytes += end - start
+ self.cache = self.fetcher(start, end) # new block replaces old
+ self.start = start
+ self.end = self.start + len(self.cache)
+ return part + self.cache[:l]
+
+
+class FirstChunkCache(BaseCache):
+ """Caches the first block of a file only
+
+ This may be useful for file types where the metadata is stored in the header,
+ but is randomly accessed.
+ """
+
+ name = "first"
+
+ def __init__(self, blocksize: int, fetcher: Fetcher, size: int) -> None:
+ if blocksize > size:
+ # this will buffer the whole thing
+ blocksize = size
+ super().__init__(blocksize, fetcher, size)
+ self.cache: bytes | None = None
+
+ def _fetch(self, start: int | None, end: int | None) -> bytes:
+ start = start or 0
+ if start > self.size:
+ logger.debug("FirstChunkCache: requested start > file size")
+ return b""
+
+ end = min(end, self.size)
+
+ if start < self.blocksize:
+ if self.cache is None:
+ self.miss_count += 1
+ if end > self.blocksize:
+ self.total_requested_bytes += end
+ data = self.fetcher(0, end)
+ self.cache = data[: self.blocksize]
+ return data[start:]
+ self.cache = self.fetcher(0, self.blocksize)
+ self.total_requested_bytes += self.blocksize
+ part = self.cache[start:end]
+ if end > self.blocksize:
+ self.total_requested_bytes += end - self.blocksize
+ part += self.fetcher(self.blocksize, end)
+ self.hit_count += 1
+ return part
+ else:
+ self.miss_count += 1
+ self.total_requested_bytes += end - start
+ return self.fetcher(start, end)
+
+
+class BlockCache(BaseCache):
+ """
+ Cache holding memory as a set of blocks.
+
+ Requests are only ever made ``blocksize`` at a time, and are
+ stored in an LRU cache. The least recently accessed block is
+ discarded when more than ``maxblocks`` are stored.
+
+ Parameters
+ ----------
+ blocksize : int
+ The number of bytes to store in each block.
+ Requests are only ever made for ``blocksize``, so this
+ should balance the overhead of making a request against
+ the granularity of the blocks.
+ fetcher : Callable
+ size : int
+ The total size of the file being cached.
+ maxblocks : int
+ The maximum number of blocks to cache for. The maximum memory
+ use for this cache is then ``blocksize * maxblocks``.
+ """
+
+ name = "blockcache"
+
+ def __init__(
+ self, blocksize: int, fetcher: Fetcher, size: int, maxblocks: int = 32
+ ) -> None:
+ super().__init__(blocksize, fetcher, size)
+ self.nblocks = math.ceil(size / blocksize)
+ self.maxblocks = maxblocks
+ self._fetch_block_cached = functools.lru_cache(maxblocks)(self._fetch_block)
+
+ def cache_info(self):
+ """
+ The statistics on the block cache.
+
+ Returns
+ -------
+ NamedTuple
+ Returned directly from the LRU Cache used internally.
+ """
+ return self._fetch_block_cached.cache_info()
+
+ def __getstate__(self) -> dict[str, Any]:
+ state = self.__dict__
+ del state["_fetch_block_cached"]
+ return state
+
+ def __setstate__(self, state: dict[str, Any]) -> None:
+ self.__dict__.update(state)
+ self._fetch_block_cached = functools.lru_cache(state["maxblocks"])(
+ self._fetch_block
+ )
+
+ def _fetch(self, start: int | None, end: int | None) -> bytes:
+ if start is None:
+ start = 0
+ if end is None:
+ end = self.size
+ if start >= self.size or start >= end:
+ return b""
+
+ # byte position -> block numbers
+ start_block_number = start // self.blocksize
+ end_block_number = end // self.blocksize
+
+ # these are cached, so safe to do multiple calls for the same start and end.
+ for block_number in range(start_block_number, end_block_number + 1):
+ self._fetch_block_cached(block_number)
+
+ return self._read_cache(
+ start,
+ end,
+ start_block_number=start_block_number,
+ end_block_number=end_block_number,
+ )
+
+ def _fetch_block(self, block_number: int) -> bytes:
+ """
+ Fetch the block of data for `block_number`.
+ """
+ if block_number > self.nblocks:
+ raise ValueError(
+ f"'block_number={block_number}' is greater than "
+ f"the number of blocks ({self.nblocks})"
+ )
+
+ start = block_number * self.blocksize
+ end = start + self.blocksize
+ self.total_requested_bytes += end - start
+ self.miss_count += 1
+ logger.info("BlockCache fetching block %d", block_number)
+ block_contents = super()._fetch(start, end)
+ return block_contents
+
+ def _read_cache(
+ self, start: int, end: int, start_block_number: int, end_block_number: int
+ ) -> bytes:
+ """
+ Read from our block cache.
+
+ Parameters
+ ----------
+ start, end : int
+ The start and end byte positions.
+ start_block_number, end_block_number : int
+ The start and end block numbers.
+ """
+ start_pos = start % self.blocksize
+ end_pos = end % self.blocksize
+
+ self.hit_count += 1
+ if start_block_number == end_block_number:
+ block: bytes = self._fetch_block_cached(start_block_number)
+ return block[start_pos:end_pos]
+
+ else:
+ # read from the initial
+ out = [self._fetch_block_cached(start_block_number)[start_pos:]]
+
+ # intermediate blocks
+ # Note: it'd be nice to combine these into one big request. However
+ # that doesn't play nicely with our LRU cache.
+ out.extend(
+ map(
+ self._fetch_block_cached,
+ range(start_block_number + 1, end_block_number),
+ )
+ )
+
+ # final block
+ out.append(self._fetch_block_cached(end_block_number)[:end_pos])
+
+ return b"".join(out)
+
+
+class BytesCache(BaseCache):
+ """Cache which holds data in a in-memory bytes object
+
+ Implements read-ahead by the block size, for semi-random reads progressing
+ through the file.
+
+ Parameters
+ ----------
+ trim: bool
+ As we read more data, whether to discard the start of the buffer when
+ we are more than a blocksize ahead of it.
+ """
+
+ name: ClassVar[str] = "bytes"
+
+ def __init__(
+ self, blocksize: int, fetcher: Fetcher, size: int, trim: bool = True
+ ) -> None:
+ super().__init__(blocksize, fetcher, size)
+ self.cache = b""
+ self.start: int | None = None
+ self.end: int | None = None
+ self.trim = trim
+
+ def _fetch(self, start: int | None, end: int | None) -> bytes:
+ # TODO: only set start/end after fetch, in case it fails?
+ # is this where retry logic might go?
+ if start is None:
+ start = 0
+ if end is None:
+ end = self.size
+ if start >= self.size or start >= end:
+ return b""
+ if (
+ self.start is not None
+ and start >= self.start
+ and self.end is not None
+ and end < self.end
+ ):
+ # cache hit: we have all the required data
+ offset = start - self.start
+ self.hit_count += 1
+ return self.cache[offset : offset + end - start]
+
+ if self.blocksize:
+ bend = min(self.size, end + self.blocksize)
+ else:
+ bend = end
+
+ if bend == start or start > self.size:
+ return b""
+
+ if (self.start is None or start < self.start) and (
+ self.end is None or end > self.end
+ ):
+ # First read, or extending both before and after
+ self.total_requested_bytes += bend - start
+ self.miss_count += 1
+ self.cache = self.fetcher(start, bend)
+ self.start = start
+ else:
+ assert self.start is not None
+ assert self.end is not None
+ self.miss_count += 1
+
+ if start < self.start:
+ if self.end is None or self.end - end > self.blocksize:
+ self.total_requested_bytes += bend - start
+ self.cache = self.fetcher(start, bend)
+ self.start = start
+ else:
+ self.total_requested_bytes += self.start - start
+ new = self.fetcher(start, self.start)
+ self.start = start
+ self.cache = new + self.cache
+ elif self.end is not None and bend > self.end:
+ if self.end > self.size:
+ pass
+ elif end - self.end > self.blocksize:
+ self.total_requested_bytes += bend - start
+ self.cache = self.fetcher(start, bend)
+ self.start = start
+ else:
+ self.total_requested_bytes += bend - self.end
+ new = self.fetcher(self.end, bend)
+ self.cache = self.cache + new
+
+ self.end = self.start + len(self.cache)
+ offset = start - self.start
+ out = self.cache[offset : offset + end - start]
+ if self.trim:
+ num = (self.end - self.start) // (self.blocksize + 1)
+ if num > 1:
+ self.start += self.blocksize * num
+ self.cache = self.cache[self.blocksize * num :]
+ return out
+
+ def __len__(self) -> int:
+ return len(self.cache)
+
+
+class AllBytes(BaseCache):
+ """Cache entire contents of the file"""
+
+ name: ClassVar[str] = "all"
+
+ def __init__(
+ self,
+ blocksize: int | None = None,
+ fetcher: Fetcher | None = None,
+ size: int | None = None,
+ data: bytes | None = None,
+ ) -> None:
+ super().__init__(blocksize, fetcher, size) # type: ignore[arg-type]
+ if data is None:
+ self.miss_count += 1
+ self.total_requested_bytes += self.size
+ data = self.fetcher(0, self.size)
+ self.data = data
+
+ def _fetch(self, start: int | None, stop: int | None) -> bytes:
+ self.hit_count += 1
+ return self.data[start:stop]
+
+
+class KnownPartsOfAFile(BaseCache):
+ """
+ Cache holding known file parts.
+
+ Parameters
+ ----------
+ blocksize: int
+ How far to read ahead in numbers of bytes
+ fetcher: func
+ Function of the form f(start, end) which gets bytes from remote as
+ specified
+ size: int
+ How big this file is
+ data: dict
+ A dictionary mapping explicit `(start, stop)` file-offset tuples
+ with known bytes.
+ strict: bool, default True
+ Whether to fetch reads that go beyond a known byte-range boundary.
+ If `False`, any read that ends outside a known part will be zero
+ padded. Note that zero padding will not be used for reads that
+ begin outside a known byte-range.
+ """
+
+ name: ClassVar[str] = "parts"
+
+ def __init__(
+ self,
+ blocksize: int,
+ fetcher: Fetcher,
+ size: int,
+ data: Optional[dict[tuple[int, int], bytes]] = None,
+ strict: bool = True,
+ **_: Any,
+ ):
+ super().__init__(blocksize, fetcher, size)
+ self.strict = strict
+
+ # simple consolidation of contiguous blocks
+ if data:
+ old_offsets = sorted(data.keys())
+ offsets = [old_offsets[0]]
+ blocks = [data.pop(old_offsets[0])]
+ for start, stop in old_offsets[1:]:
+ start0, stop0 = offsets[-1]
+ if start == stop0:
+ offsets[-1] = (start0, stop)
+ blocks[-1] += data.pop((start, stop))
+ else:
+ offsets.append((start, stop))
+ blocks.append(data.pop((start, stop)))
+
+ self.data = dict(zip(offsets, blocks))
+ else:
+ self.data = {}
+
+ def _fetch(self, start: int | None, stop: int | None) -> bytes:
+ if start is None:
+ start = 0
+ if stop is None:
+ stop = self.size
+
+ out = b""
+ for (loc0, loc1), data in self.data.items():
+ # If self.strict=False, use zero-padded data
+ # for reads beyond the end of a "known" buffer
+ if loc0 <= start < loc1:
+ off = start - loc0
+ out = data[off : off + stop - start]
+ if not self.strict or loc0 <= stop <= loc1:
+ # The request is within a known range, or
+ # it begins within a known range, and we
+ # are allowed to pad reads beyond the
+ # buffer with zero
+ out += b"\x00" * (stop - start - len(out))
+ self.hit_count += 1
+ return out
+ else:
+ # The request ends outside a known range,
+ # and we are being "strict" about reads
+ # beyond the buffer
+ start = loc1
+ break
+
+ # We only get here if there is a request outside the
+ # known parts of the file. In an ideal world, this
+ # should never happen
+ if self.fetcher is None:
+ # We cannot fetch the data, so raise an error
+ raise ValueError(f"Read is outside the known file parts: {(start, stop)}. ")
+ # We can fetch the data, but should warn the user
+ # that this may be slow
+ warnings.warn(
+ f"Read is outside the known file parts: {(start, stop)}. "
+ f"IO/caching performance may be poor!"
+ )
+ logger.debug(f"KnownPartsOfAFile cache fetching {start}-{stop}")
+ self.total_requested_bytes += stop - start
+ self.miss_count += 1
+ return out + super()._fetch(start, stop)
+
+
+class UpdatableLRU(Generic[P, T]):
+ """
+ Custom implementation of LRU cache that allows updating keys
+
+ Used by BackgroudBlockCache
+ """
+
+ class CacheInfo(NamedTuple):
+ hits: int
+ misses: int
+ maxsize: int
+ currsize: int
+
+ def __init__(self, func: Callable[P, T], max_size: int = 128) -> None:
+ self._cache: OrderedDict[Any, T] = collections.OrderedDict()
+ self._func = func
+ self._max_size = max_size
+ self._hits = 0
+ self._misses = 0
+ self._lock = threading.Lock()
+
+ def __call__(self, *args: P.args, **kwargs: P.kwargs) -> T:
+ if kwargs:
+ raise TypeError(f"Got unexpected keyword argument {kwargs.keys()}")
+ with self._lock:
+ if args in self._cache:
+ self._cache.move_to_end(args)
+ self._hits += 1
+ return self._cache[args]
+
+ result = self._func(*args, **kwargs)
+
+ with self._lock:
+ self._cache[args] = result
+ self._misses += 1
+ if len(self._cache) > self._max_size:
+ self._cache.popitem(last=False)
+
+ return result
+
+ def is_key_cached(self, *args: Any) -> bool:
+ with self._lock:
+ return args in self._cache
+
+ def add_key(self, result: T, *args: Any) -> None:
+ with self._lock:
+ self._cache[args] = result
+ if len(self._cache) > self._max_size:
+ self._cache.popitem(last=False)
+
+ def cache_info(self) -> UpdatableLRU.CacheInfo:
+ with self._lock:
+ return self.CacheInfo(
+ maxsize=self._max_size,
+ currsize=len(self._cache),
+ hits=self._hits,
+ misses=self._misses,
+ )
+
+
+class BackgroundBlockCache(BaseCache):
+ """
+ Cache holding memory as a set of blocks with pre-loading of
+ the next block in the background.
+
+ Requests are only ever made ``blocksize`` at a time, and are
+ stored in an LRU cache. The least recently accessed block is
+ discarded when more than ``maxblocks`` are stored. If the
+ next block is not in cache, it is loaded in a separate thread
+ in non-blocking way.
+
+ Parameters
+ ----------
+ blocksize : int
+ The number of bytes to store in each block.
+ Requests are only ever made for ``blocksize``, so this
+ should balance the overhead of making a request against
+ the granularity of the blocks.
+ fetcher : Callable
+ size : int
+ The total size of the file being cached.
+ maxblocks : int
+ The maximum number of blocks to cache for. The maximum memory
+ use for this cache is then ``blocksize * maxblocks``.
+ """
+
+ name: ClassVar[str] = "background"
+
+ def __init__(
+ self, blocksize: int, fetcher: Fetcher, size: int, maxblocks: int = 32
+ ) -> None:
+ super().__init__(blocksize, fetcher, size)
+ self.nblocks = math.ceil(size / blocksize)
+ self.maxblocks = maxblocks
+ self._fetch_block_cached = UpdatableLRU(self._fetch_block, maxblocks)
+
+ self._thread_executor = ThreadPoolExecutor(max_workers=1)
+ self._fetch_future_block_number: int | None = None
+ self._fetch_future: Future[bytes] | None = None
+ self._fetch_future_lock = threading.Lock()
+
+ def cache_info(self) -> UpdatableLRU.CacheInfo:
+ """
+ The statistics on the block cache.
+
+ Returns
+ -------
+ NamedTuple
+ Returned directly from the LRU Cache used internally.
+ """
+ return self._fetch_block_cached.cache_info()
+
+ def __getstate__(self) -> dict[str, Any]:
+ state = self.__dict__
+ del state["_fetch_block_cached"]
+ del state["_thread_executor"]
+ del state["_fetch_future_block_number"]
+ del state["_fetch_future"]
+ del state["_fetch_future_lock"]
+ return state
+
+ def __setstate__(self, state) -> None:
+ self.__dict__.update(state)
+ self._fetch_block_cached = UpdatableLRU(self._fetch_block, state["maxblocks"])
+ self._thread_executor = ThreadPoolExecutor(max_workers=1)
+ self._fetch_future_block_number = None
+ self._fetch_future = None
+ self._fetch_future_lock = threading.Lock()
+
+ def _fetch(self, start: int | None, end: int | None) -> bytes:
+ if start is None:
+ start = 0
+ if end is None:
+ end = self.size
+ if start >= self.size or start >= end:
+ return b""
+
+ # byte position -> block numbers
+ start_block_number = start // self.blocksize
+ end_block_number = end // self.blocksize
+
+ fetch_future_block_number = None
+ fetch_future = None
+ with self._fetch_future_lock:
+ # Background thread is running. Check we we can or must join it.
+ if self._fetch_future is not None:
+ assert self._fetch_future_block_number is not None
+ if self._fetch_future.done():
+ logger.info("BlockCache joined background fetch without waiting.")
+ self._fetch_block_cached.add_key(
+ self._fetch_future.result(), self._fetch_future_block_number
+ )
+ # Cleanup the fetch variables. Done with fetching the block.
+ self._fetch_future_block_number = None
+ self._fetch_future = None
+ else:
+ # Must join if we need the block for the current fetch
+ must_join = bool(
+ start_block_number
+ <= self._fetch_future_block_number
+ <= end_block_number
+ )
+ if must_join:
+ # Copy to the local variables to release lock
+ # before waiting for result
+ fetch_future_block_number = self._fetch_future_block_number
+ fetch_future = self._fetch_future
+
+ # Cleanup the fetch variables. Have a local copy.
+ self._fetch_future_block_number = None
+ self._fetch_future = None
+
+ # Need to wait for the future for the current read
+ if fetch_future is not None:
+ logger.info("BlockCache waiting for background fetch.")
+ # Wait until result and put it in cache
+ self._fetch_block_cached.add_key(
+ fetch_future.result(), fetch_future_block_number
+ )
+
+ # these are cached, so safe to do multiple calls for the same start and end.
+ for block_number in range(start_block_number, end_block_number + 1):
+ self._fetch_block_cached(block_number)
+
+ # fetch next block in the background if nothing is running in the background,
+ # the block is within file and it is not already cached
+ end_block_plus_1 = end_block_number + 1
+ with self._fetch_future_lock:
+ if (
+ self._fetch_future is None
+ and end_block_plus_1 <= self.nblocks
+ and not self._fetch_block_cached.is_key_cached(end_block_plus_1)
+ ):
+ self._fetch_future_block_number = end_block_plus_1
+ self._fetch_future = self._thread_executor.submit(
+ self._fetch_block, end_block_plus_1, "async"
+ )
+
+ return self._read_cache(
+ start,
+ end,
+ start_block_number=start_block_number,
+ end_block_number=end_block_number,
+ )
+
+ def _fetch_block(self, block_number: int, log_info: str = "sync") -> bytes:
+ """
+ Fetch the block of data for `block_number`.
+ """
+ if block_number > self.nblocks:
+ raise ValueError(
+ f"'block_number={block_number}' is greater than "
+ f"the number of blocks ({self.nblocks})"
+ )
+
+ start = block_number * self.blocksize
+ end = start + self.blocksize
+ logger.info("BlockCache fetching block (%s) %d", log_info, block_number)
+ self.total_requested_bytes += end - start
+ self.miss_count += 1
+ block_contents = super()._fetch(start, end)
+ return block_contents
+
+ def _read_cache(
+ self, start: int, end: int, start_block_number: int, end_block_number: int
+ ) -> bytes:
+ """
+ Read from our block cache.
+
+ Parameters
+ ----------
+ start, end : int
+ The start and end byte positions.
+ start_block_number, end_block_number : int
+ The start and end block numbers.
+ """
+ start_pos = start % self.blocksize
+ end_pos = end % self.blocksize
+
+ # kind of pointless to count this as a hit, but it is
+ self.hit_count += 1
+
+ if start_block_number == end_block_number:
+ block = self._fetch_block_cached(start_block_number)
+ return block[start_pos:end_pos]
+
+ else:
+ # read from the initial
+ out = [self._fetch_block_cached(start_block_number)[start_pos:]]
+
+ # intermediate blocks
+ # Note: it'd be nice to combine these into one big request. However
+ # that doesn't play nicely with our LRU cache.
+ out.extend(
+ map(
+ self._fetch_block_cached,
+ range(start_block_number + 1, end_block_number),
+ )
+ )
+
+ # final block
+ out.append(self._fetch_block_cached(end_block_number)[:end_pos])
+
+ return b"".join(out)
+
+
+caches: dict[str | None, type[BaseCache]] = {
+ # one custom case
+ None: BaseCache,
+}
+
+
+def register_cache(cls: type[BaseCache], clobber: bool = False) -> None:
+ """'Register' cache implementation.
+
+ Parameters
+ ----------
+ clobber: bool, optional
+ If set to True (default is False) - allow to overwrite existing
+ entry.
+
+ Raises
+ ------
+ ValueError
+ """
+ name = cls.name
+ if not clobber and name in caches:
+ raise ValueError(f"Cache with name {name!r} is already known: {caches[name]}")
+ caches[name] = cls
+
+
+for c in (
+ BaseCache,
+ MMapCache,
+ BytesCache,
+ ReadAheadCache,
+ BlockCache,
+ FirstChunkCache,
+ AllBytes,
+ KnownPartsOfAFile,
+ BackgroundBlockCache,
+):
+ register_cache(c)
diff --git a/parrot/lib/python3.10/site-packages/fsspec/callbacks.py b/parrot/lib/python3.10/site-packages/fsspec/callbacks.py
new file mode 100644
index 0000000000000000000000000000000000000000..7ca99ca6ac3cd69b28bcd1550f6550e8e648c5fe
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/fsspec/callbacks.py
@@ -0,0 +1,324 @@
+from functools import wraps
+
+
+class Callback:
+ """
+ Base class and interface for callback mechanism
+
+ This class can be used directly for monitoring file transfers by
+ providing ``callback=Callback(hooks=...)`` (see the ``hooks`` argument,
+ below), or subclassed for more specialised behaviour.
+
+ Parameters
+ ----------
+ size: int (optional)
+ Nominal quantity for the value that corresponds to a complete
+ transfer, e.g., total number of tiles or total number of
+ bytes
+ value: int (0)
+ Starting internal counter value
+ hooks: dict or None
+ A dict of named functions to be called on each update. The signature
+ of these must be ``f(size, value, **kwargs)``
+ """
+
+ def __init__(self, size=None, value=0, hooks=None, **kwargs):
+ self.size = size
+ self.value = value
+ self.hooks = hooks or {}
+ self.kw = kwargs
+
+ def __enter__(self):
+ return self
+
+ def __exit__(self, *exc_args):
+ self.close()
+
+ def close(self):
+ """Close callback."""
+
+ def branched(self, path_1, path_2, **kwargs):
+ """
+ Return callback for child transfers
+
+ If this callback is operating at a higher level, e.g., put, which may
+ trigger transfers that can also be monitored. The function returns a callback
+ that has to be passed to the child method, e.g., put_file,
+ as `callback=` argument.
+
+ The implementation uses `callback.branch` for compatibility.
+ When implementing callbacks, it is recommended to override this function instead
+ of `branch` and avoid calling `super().branched(...)`.
+
+ Prefer using this function over `branch`.
+
+ Parameters
+ ----------
+ path_1: str
+ Child's source path
+ path_2: str
+ Child's destination path
+ **kwargs:
+ Arbitrary keyword arguments
+
+ Returns
+ -------
+ callback: Callback
+ A callback instance to be passed to the child method
+ """
+ self.branch(path_1, path_2, kwargs)
+ # mutate kwargs so that we can force the caller to pass "callback=" explicitly
+ return kwargs.pop("callback", DEFAULT_CALLBACK)
+
+ def branch_coro(self, fn):
+ """
+ Wraps a coroutine, and pass a new child callback to it.
+ """
+
+ @wraps(fn)
+ async def func(path1, path2: str, **kwargs):
+ with self.branched(path1, path2, **kwargs) as child:
+ return await fn(path1, path2, callback=child, **kwargs)
+
+ return func
+
+ def set_size(self, size):
+ """
+ Set the internal maximum size attribute
+
+ Usually called if not initially set at instantiation. Note that this
+ triggers a ``call()``.
+
+ Parameters
+ ----------
+ size: int
+ """
+ self.size = size
+ self.call()
+
+ def absolute_update(self, value):
+ """
+ Set the internal value state
+
+ Triggers ``call()``
+
+ Parameters
+ ----------
+ value: int
+ """
+ self.value = value
+ self.call()
+
+ def relative_update(self, inc=1):
+ """
+ Delta increment the internal counter
+
+ Triggers ``call()``
+
+ Parameters
+ ----------
+ inc: int
+ """
+ self.value += inc
+ self.call()
+
+ def call(self, hook_name=None, **kwargs):
+ """
+ Execute hook(s) with current state
+
+ Each function is passed the internal size and current value
+
+ Parameters
+ ----------
+ hook_name: str or None
+ If given, execute on this hook
+ kwargs: passed on to (all) hook(s)
+ """
+ if not self.hooks:
+ return
+ kw = self.kw.copy()
+ kw.update(kwargs)
+ if hook_name:
+ if hook_name not in self.hooks:
+ return
+ return self.hooks[hook_name](self.size, self.value, **kw)
+ for hook in self.hooks.values() or []:
+ hook(self.size, self.value, **kw)
+
+ def wrap(self, iterable):
+ """
+ Wrap an iterable to call ``relative_update`` on each iterations
+
+ Parameters
+ ----------
+ iterable: Iterable
+ The iterable that is being wrapped
+ """
+ for item in iterable:
+ self.relative_update()
+ yield item
+
+ def branch(self, path_1, path_2, kwargs):
+ """
+ Set callbacks for child transfers
+
+ If this callback is operating at a higher level, e.g., put, which may
+ trigger transfers that can also be monitored. The passed kwargs are
+ to be *mutated* to add ``callback=``, if this class supports branching
+ to children.
+
+ Parameters
+ ----------
+ path_1: str
+ Child's source path
+ path_2: str
+ Child's destination path
+ kwargs: dict
+ arguments passed to child method, e.g., put_file.
+
+ Returns
+ -------
+
+ """
+ return None
+
+ def no_op(self, *_, **__):
+ pass
+
+ def __getattr__(self, item):
+ """
+ If undefined methods are called on this class, nothing happens
+ """
+ return self.no_op
+
+ @classmethod
+ def as_callback(cls, maybe_callback=None):
+ """Transform callback=... into Callback instance
+
+ For the special value of ``None``, return the global instance of
+ ``NoOpCallback``. This is an alternative to including
+ ``callback=DEFAULT_CALLBACK`` directly in a method signature.
+ """
+ if maybe_callback is None:
+ return DEFAULT_CALLBACK
+ return maybe_callback
+
+
+class NoOpCallback(Callback):
+ """
+ This implementation of Callback does exactly nothing
+ """
+
+ def call(self, *args, **kwargs):
+ return None
+
+
+class DotPrinterCallback(Callback):
+ """
+ Simple example Callback implementation
+
+ Almost identical to Callback with a hook that prints a char; here we
+ demonstrate how the outer layer may print "#" and the inner layer "."
+ """
+
+ def __init__(self, chr_to_print="#", **kwargs):
+ self.chr = chr_to_print
+ super().__init__(**kwargs)
+
+ def branch(self, path_1, path_2, kwargs):
+ """Mutate kwargs to add new instance with different print char"""
+ kwargs["callback"] = DotPrinterCallback(".")
+
+ def call(self, **kwargs):
+ """Just outputs a character"""
+ print(self.chr, end="")
+
+
+class TqdmCallback(Callback):
+ """
+ A callback to display a progress bar using tqdm
+
+ Parameters
+ ----------
+ tqdm_kwargs : dict, (optional)
+ Any argument accepted by the tqdm constructor.
+ See the `tqdm doc `_.
+ Will be forwarded to `tqdm_cls`.
+ tqdm_cls: (optional)
+ subclass of `tqdm.tqdm`. If not passed, it will default to `tqdm.tqdm`.
+
+ Examples
+ --------
+ >>> import fsspec
+ >>> from fsspec.callbacks import TqdmCallback
+ >>> fs = fsspec.filesystem("memory")
+ >>> path2distant_data = "/your-path"
+ >>> fs.upload(
+ ".",
+ path2distant_data,
+ recursive=True,
+ callback=TqdmCallback(),
+ )
+
+ You can forward args to tqdm using the ``tqdm_kwargs`` parameter.
+
+ >>> fs.upload(
+ ".",
+ path2distant_data,
+ recursive=True,
+ callback=TqdmCallback(tqdm_kwargs={"desc": "Your tqdm description"}),
+ )
+
+ You can also customize the progress bar by passing a subclass of `tqdm`.
+
+ .. code-block:: python
+
+ class TqdmFormat(tqdm):
+ '''Provides a `total_time` format parameter'''
+ @property
+ def format_dict(self):
+ d = super().format_dict
+ total_time = d["elapsed"] * (d["total"] or 0) / max(d["n"], 1)
+ d.update(total_time=self.format_interval(total_time) + " in total")
+ return d
+
+ >>> with TqdmCallback(
+ tqdm_kwargs={
+ "desc": "desc",
+ "bar_format": "{total_time}: {percentage:.0f}%|{bar}{r_bar}",
+ },
+ tqdm_cls=TqdmFormat,
+ ) as callback:
+ fs.upload(".", path2distant_data, recursive=True, callback=callback)
+ """
+
+ def __init__(self, tqdm_kwargs=None, *args, **kwargs):
+ try:
+ from tqdm import tqdm
+
+ except ImportError as exce:
+ raise ImportError(
+ "Using TqdmCallback requires tqdm to be installed"
+ ) from exce
+
+ self._tqdm_cls = kwargs.pop("tqdm_cls", tqdm)
+ self._tqdm_kwargs = tqdm_kwargs or {}
+ self.tqdm = None
+ super().__init__(*args, **kwargs)
+
+ def call(self, *args, **kwargs):
+ if self.tqdm is None:
+ self.tqdm = self._tqdm_cls(total=self.size, **self._tqdm_kwargs)
+ self.tqdm.total = self.size
+ self.tqdm.update(self.value - self.tqdm.n)
+
+ def close(self):
+ if self.tqdm is not None:
+ self.tqdm.close()
+ self.tqdm = None
+
+ def __del__(self):
+ return self.close()
+
+
+DEFAULT_CALLBACK = _DEFAULT_CALLBACK = NoOpCallback()
diff --git a/parrot/lib/python3.10/site-packages/fsspec/compression.py b/parrot/lib/python3.10/site-packages/fsspec/compression.py
new file mode 100644
index 0000000000000000000000000000000000000000..fc519c24532fdcd3f6f1b3fc645d38e1e1dde1d7
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/fsspec/compression.py
@@ -0,0 +1,175 @@
+"""Helper functions for a standard streaming compression API"""
+
+from zipfile import ZipFile
+
+import fsspec.utils
+from fsspec.spec import AbstractBufferedFile
+
+
+def noop_file(file, mode, **kwargs):
+ return file
+
+
+# TODO: files should also be available as contexts
+# should be functions of the form func(infile, mode=, **kwargs) -> file-like
+compr = {None: noop_file}
+
+
+def register_compression(name, callback, extensions, force=False):
+ """Register an "inferable" file compression type.
+
+ Registers transparent file compression type for use with fsspec.open.
+ Compression can be specified by name in open, or "infer"-ed for any files
+ ending with the given extensions.
+
+ Args:
+ name: (str) The compression type name. Eg. "gzip".
+ callback: A callable of form (infile, mode, **kwargs) -> file-like.
+ Accepts an input file-like object, the target mode and kwargs.
+ Returns a wrapped file-like object.
+ extensions: (str, Iterable[str]) A file extension, or list of file
+ extensions for which to infer this compression scheme. Eg. "gz".
+ force: (bool) Force re-registration of compression type or extensions.
+
+ Raises:
+ ValueError: If name or extensions already registered, and not force.
+
+ """
+ if isinstance(extensions, str):
+ extensions = [extensions]
+
+ # Validate registration
+ if name in compr and not force:
+ raise ValueError(f"Duplicate compression registration: {name}")
+
+ for ext in extensions:
+ if ext in fsspec.utils.compressions and not force:
+ raise ValueError(f"Duplicate compression file extension: {ext} ({name})")
+
+ compr[name] = callback
+
+ for ext in extensions:
+ fsspec.utils.compressions[ext] = name
+
+
+def unzip(infile, mode="rb", filename=None, **kwargs):
+ if "r" not in mode:
+ filename = filename or "file"
+ z = ZipFile(infile, mode="w", **kwargs)
+ fo = z.open(filename, mode="w")
+ fo.close = lambda closer=fo.close: closer() or z.close()
+ return fo
+ z = ZipFile(infile)
+ if filename is None:
+ filename = z.namelist()[0]
+ return z.open(filename, mode="r", **kwargs)
+
+
+register_compression("zip", unzip, "zip")
+
+try:
+ from bz2 import BZ2File
+except ImportError:
+ pass
+else:
+ register_compression("bz2", BZ2File, "bz2")
+
+try: # pragma: no cover
+ from isal import igzip
+
+ def isal(infile, mode="rb", **kwargs):
+ return igzip.IGzipFile(fileobj=infile, mode=mode, **kwargs)
+
+ register_compression("gzip", isal, "gz")
+except ImportError:
+ from gzip import GzipFile
+
+ register_compression(
+ "gzip", lambda f, **kwargs: GzipFile(fileobj=f, **kwargs), "gz"
+ )
+
+try:
+ from lzma import LZMAFile
+
+ register_compression("lzma", LZMAFile, "lzma")
+ register_compression("xz", LZMAFile, "xz")
+except ImportError:
+ pass
+
+try:
+ import lzmaffi
+
+ register_compression("lzma", lzmaffi.LZMAFile, "lzma", force=True)
+ register_compression("xz", lzmaffi.LZMAFile, "xz", force=True)
+except ImportError:
+ pass
+
+
+class SnappyFile(AbstractBufferedFile):
+ def __init__(self, infile, mode, **kwargs):
+ import snappy
+
+ super().__init__(
+ fs=None, path="snappy", mode=mode.strip("b") + "b", size=999999999, **kwargs
+ )
+ self.infile = infile
+ if "r" in mode:
+ self.codec = snappy.StreamDecompressor()
+ else:
+ self.codec = snappy.StreamCompressor()
+
+ def _upload_chunk(self, final=False):
+ self.buffer.seek(0)
+ out = self.codec.add_chunk(self.buffer.read())
+ self.infile.write(out)
+ return True
+
+ def seek(self, loc, whence=0):
+ raise NotImplementedError("SnappyFile is not seekable")
+
+ def seekable(self):
+ return False
+
+ def _fetch_range(self, start, end):
+ """Get the specified set of bytes from remote"""
+ data = self.infile.read(end - start)
+ return self.codec.decompress(data)
+
+
+try:
+ import snappy
+
+ snappy.compress(b"")
+ # Snappy may use the .sz file extension, but this is not part of the
+ # standard implementation.
+ register_compression("snappy", SnappyFile, [])
+
+except (ImportError, NameError, AttributeError):
+ pass
+
+try:
+ import lz4.frame
+
+ register_compression("lz4", lz4.frame.open, "lz4")
+except ImportError:
+ pass
+
+try:
+ import zstandard as zstd
+
+ def zstandard_file(infile, mode="rb"):
+ if "r" in mode:
+ cctx = zstd.ZstdDecompressor()
+ return cctx.stream_reader(infile)
+ else:
+ cctx = zstd.ZstdCompressor(level=10)
+ return cctx.stream_writer(infile)
+
+ register_compression("zstd", zstandard_file, "zst")
+except ImportError:
+ pass
+
+
+def available_compressions():
+ """Return a list of the implemented compressions."""
+ return list(compr)
diff --git a/parrot/lib/python3.10/site-packages/fsspec/config.py b/parrot/lib/python3.10/site-packages/fsspec/config.py
new file mode 100644
index 0000000000000000000000000000000000000000..76d9af14aaf7df47c4551c169f27b05abf9c269e
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/fsspec/config.py
@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import configparser
+import json
+import os
+import warnings
+from typing import Any
+
+conf: dict[str, dict[str, Any]] = {}
+default_conf_dir = os.path.join(os.path.expanduser("~"), ".config/fsspec")
+conf_dir = os.environ.get("FSSPEC_CONFIG_DIR", default_conf_dir)
+
+
+def set_conf_env(conf_dict, envdict=os.environ):
+ """Set config values from environment variables
+
+ Looks for variables of the form ``FSSPEC_`` and
+ ``FSSPEC__``. For ``FSSPEC_`` the value is parsed
+ as a json dictionary and used to ``update`` the config of the
+ corresponding protocol. For ``FSSPEC__`` there is no
+ attempt to convert the string value, but the kwarg keys will be lower-cased.
+
+ The ``FSSPEC__`` variables are applied after the
+ ``FSSPEC_`` ones.
+
+ Parameters
+ ----------
+ conf_dict : dict(str, dict)
+ This dict will be mutated
+ envdict : dict-like(str, str)
+ Source for the values - usually the real environment
+ """
+ kwarg_keys = []
+ for key in envdict:
+ if key.startswith("FSSPEC_") and len(key) > 7 and key[7] != "_":
+ if key.count("_") > 1:
+ kwarg_keys.append(key)
+ continue
+ try:
+ value = json.loads(envdict[key])
+ except json.decoder.JSONDecodeError as ex:
+ warnings.warn(
+ f"Ignoring environment variable {key} due to a parse failure: {ex}"
+ )
+ else:
+ if isinstance(value, dict):
+ _, proto = key.split("_", 1)
+ conf_dict.setdefault(proto.lower(), {}).update(value)
+ else:
+ warnings.warn(
+ f"Ignoring environment variable {key} due to not being a dict:"
+ f" {type(value)}"
+ )
+ elif key.startswith("FSSPEC"):
+ warnings.warn(
+ f"Ignoring environment variable {key} due to having an unexpected name"
+ )
+
+ for key in kwarg_keys:
+ _, proto, kwarg = key.split("_", 2)
+ conf_dict.setdefault(proto.lower(), {})[kwarg.lower()] = envdict[key]
+
+
+def set_conf_files(cdir, conf_dict):
+ """Set config values from files
+
+ Scans for INI and JSON files in the given dictionary, and uses their
+ contents to set the config. In case of repeated values, later values
+ win.
+
+ In the case of INI files, all values are strings, and these will not
+ be converted.
+
+ Parameters
+ ----------
+ cdir : str
+ Directory to search
+ conf_dict : dict(str, dict)
+ This dict will be mutated
+ """
+ if not os.path.isdir(cdir):
+ return
+ allfiles = sorted(os.listdir(cdir))
+ for fn in allfiles:
+ if fn.endswith(".ini"):
+ ini = configparser.ConfigParser()
+ ini.read(os.path.join(cdir, fn))
+ for key in ini:
+ if key == "DEFAULT":
+ continue
+ conf_dict.setdefault(key, {}).update(dict(ini[key]))
+ if fn.endswith(".json"):
+ with open(os.path.join(cdir, fn)) as f:
+ js = json.load(f)
+ for key in js:
+ conf_dict.setdefault(key, {}).update(dict(js[key]))
+
+
+def apply_config(cls, kwargs, conf_dict=None):
+ """Supply default values for kwargs when instantiating class
+
+ Augments the passed kwargs, by finding entries in the config dict
+ which match the classes ``.protocol`` attribute (one or more str)
+
+ Parameters
+ ----------
+ cls : file system implementation
+ kwargs : dict
+ conf_dict : dict of dict
+ Typically this is the global configuration
+
+ Returns
+ -------
+ dict : the modified set of kwargs
+ """
+ if conf_dict is None:
+ conf_dict = conf
+ protos = cls.protocol if isinstance(cls.protocol, (tuple, list)) else [cls.protocol]
+ kw = {}
+ for proto in protos:
+ # default kwargs from the current state of the config
+ if proto in conf_dict:
+ kw.update(conf_dict[proto])
+ # explicit kwargs always win
+ kw.update(**kwargs)
+ kwargs = kw
+ return kwargs
+
+
+set_conf_files(conf_dir, conf)
+set_conf_env(conf)
diff --git a/parrot/lib/python3.10/site-packages/fsspec/conftest.py b/parrot/lib/python3.10/site-packages/fsspec/conftest.py
new file mode 100644
index 0000000000000000000000000000000000000000..6874a42c4895c3c7b973dc5d63fd4488a4e60b44
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/fsspec/conftest.py
@@ -0,0 +1,55 @@
+import os
+import shutil
+import subprocess
+import sys
+import time
+
+import pytest
+
+import fsspec
+from fsspec.implementations.cached import CachingFileSystem
+
+
+@pytest.fixture()
+def m():
+ """
+ Fixture providing a memory filesystem.
+ """
+ m = fsspec.filesystem("memory")
+ m.store.clear()
+ m.pseudo_dirs.clear()
+ m.pseudo_dirs.append("")
+ try:
+ yield m
+ finally:
+ m.store.clear()
+ m.pseudo_dirs.clear()
+ m.pseudo_dirs.append("")
+
+
+@pytest.fixture
+def ftp_writable(tmpdir):
+ """
+ Fixture providing a writable FTP filesystem.
+ """
+ pytest.importorskip("pyftpdlib")
+ from fsspec.implementations.ftp import FTPFileSystem
+
+ FTPFileSystem.clear_instance_cache() # remove lingering connections
+ CachingFileSystem.clear_instance_cache()
+ d = str(tmpdir)
+ with open(os.path.join(d, "out"), "wb") as f:
+ f.write(b"hello" * 10000)
+ P = subprocess.Popen(
+ [sys.executable, "-m", "pyftpdlib", "-d", d, "-u", "user", "-P", "pass", "-w"]
+ )
+ try:
+ time.sleep(1)
+ yield "localhost", 2121, "user", "pass"
+ finally:
+ P.terminate()
+ P.wait()
+ try:
+ shutil.rmtree(tmpdir)
+ except Exception:
+ pass
diff --git a/parrot/lib/python3.10/site-packages/fsspec/core.py b/parrot/lib/python3.10/site-packages/fsspec/core.py
new file mode 100644
index 0000000000000000000000000000000000000000..bd4f98d13ab69a7eb85dc60f8c9b2a977072d908
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/fsspec/core.py
@@ -0,0 +1,738 @@
+from __future__ import annotations
+
+import io
+import logging
+import os
+import re
+from glob import has_magic
+from pathlib import Path
+
+# for backwards compat, we export cache things from here too
+from fsspec.caching import ( # noqa: F401
+ BaseCache,
+ BlockCache,
+ BytesCache,
+ MMapCache,
+ ReadAheadCache,
+ caches,
+)
+from fsspec.compression import compr
+from fsspec.config import conf
+from fsspec.registry import filesystem, get_filesystem_class
+from fsspec.utils import (
+ _unstrip_protocol,
+ build_name_function,
+ infer_compression,
+ stringify_path,
+)
+
+logger = logging.getLogger("fsspec")
+
+
+class OpenFile:
+ """
+ File-like object to be used in a context
+
+ Can layer (buffered) text-mode and compression over any file-system, which
+ are typically binary-only.
+
+ These instances are safe to serialize, as the low-level file object
+ is not created until invoked using ``with``.
+
+ Parameters
+ ----------
+ fs: FileSystem
+ The file system to use for opening the file. Should be a subclass or duck-type
+ with ``fsspec.spec.AbstractFileSystem``
+ path: str
+ Location to open
+ mode: str like 'rb', optional
+ Mode of the opened file
+ compression: str or None, optional
+ Compression to apply
+ encoding: str or None, optional
+ The encoding to use if opened in text mode.
+ errors: str or None, optional
+ How to handle encoding errors if opened in text mode.
+ newline: None or str
+ Passed to TextIOWrapper in text mode, how to handle line endings.
+ autoopen: bool
+ If True, calls open() immediately. Mostly used by pickle
+ pos: int
+ If given and autoopen is True, seek to this location immediately
+ """
+
+ def __init__(
+ self,
+ fs,
+ path,
+ mode="rb",
+ compression=None,
+ encoding=None,
+ errors=None,
+ newline=None,
+ ):
+ self.fs = fs
+ self.path = path
+ self.mode = mode
+ self.compression = get_compression(path, compression)
+ self.encoding = encoding
+ self.errors = errors
+ self.newline = newline
+ self.fobjects = []
+
+ def __reduce__(self):
+ return (
+ OpenFile,
+ (
+ self.fs,
+ self.path,
+ self.mode,
+ self.compression,
+ self.encoding,
+ self.errors,
+ self.newline,
+ ),
+ )
+
+ def __repr__(self):
+ return f""
+
+ def __enter__(self):
+ mode = self.mode.replace("t", "").replace("b", "") + "b"
+
+ try:
+ f = self.fs.open(self.path, mode=mode)
+ except FileNotFoundError as e:
+ if has_magic(self.path):
+ raise FileNotFoundError(
+ "%s not found. The URL contains glob characters: you maybe needed\n"
+ "to pass expand=True in fsspec.open() or the storage_options of \n"
+ "your library. You can also set the config value 'open_expand'\n"
+ "before import, or fsspec.core.DEFAULT_EXPAND at runtime, to True.",
+ self.path,
+ ) from e
+ raise
+
+ self.fobjects = [f]
+
+ if self.compression is not None:
+ compress = compr[self.compression]
+ f = compress(f, mode=mode[0])
+ self.fobjects.append(f)
+
+ if "b" not in self.mode:
+ # assume, for example, that 'r' is equivalent to 'rt' as in builtin
+ f = PickleableTextIOWrapper(
+ f, encoding=self.encoding, errors=self.errors, newline=self.newline
+ )
+ self.fobjects.append(f)
+
+ return self.fobjects[-1]
+
+ def __exit__(self, *args):
+ self.close()
+
+ @property
+ def full_name(self):
+ return _unstrip_protocol(self.path, self.fs)
+
+ def open(self):
+ """Materialise this as a real open file without context
+
+ The OpenFile object should be explicitly closed to avoid enclosed file
+ instances persisting. You must, therefore, keep a reference to the OpenFile
+ during the life of the file-like it generates.
+ """
+ return self.__enter__()
+
+ def close(self):
+ """Close all encapsulated file objects"""
+ for f in reversed(self.fobjects):
+ if "r" not in self.mode and not f.closed:
+ f.flush()
+ f.close()
+ self.fobjects.clear()
+
+
+class OpenFiles(list):
+ """List of OpenFile instances
+
+ Can be used in a single context, which opens and closes all of the
+ contained files. Normal list access to get the elements works as
+ normal.
+
+ A special case is made for caching filesystems - the files will
+ be down/uploaded together at the start or end of the context, and
+ this may happen concurrently, if the target filesystem supports it.
+ """
+
+ def __init__(self, *args, mode="rb", fs=None):
+ self.mode = mode
+ self.fs = fs
+ self.files = []
+ super().__init__(*args)
+
+ def __enter__(self):
+ if self.fs is None:
+ raise ValueError("Context has already been used")
+
+ fs = self.fs
+ while True:
+ if hasattr(fs, "open_many"):
+ # check for concurrent cache download; or set up for upload
+ self.files = fs.open_many(self)
+ return self.files
+ if hasattr(fs, "fs") and fs.fs is not None:
+ fs = fs.fs
+ else:
+ break
+ return [s.__enter__() for s in self]
+
+ def __exit__(self, *args):
+ fs = self.fs
+ [s.__exit__(*args) for s in self]
+ if "r" not in self.mode:
+ while True:
+ if hasattr(fs, "open_many"):
+ # check for concurrent cache upload
+ fs.commit_many(self.files)
+ return
+ if hasattr(fs, "fs") and fs.fs is not None:
+ fs = fs.fs
+ else:
+ break
+
+ def __getitem__(self, item):
+ out = super().__getitem__(item)
+ if isinstance(item, slice):
+ return OpenFiles(out, mode=self.mode, fs=self.fs)
+ return out
+
+ def __repr__(self):
+ return f""
+
+
+def open_files(
+ urlpath,
+ mode="rb",
+ compression=None,
+ encoding="utf8",
+ errors=None,
+ name_function=None,
+ num=1,
+ protocol=None,
+ newline=None,
+ auto_mkdir=True,
+ expand=True,
+ **kwargs,
+):
+ """Given a path or paths, return a list of ``OpenFile`` objects.
+
+ For writing, a str path must contain the "*" character, which will be filled
+ in by increasing numbers, e.g., "part*" -> "part1", "part2" if num=2.
+
+ For either reading or writing, can instead provide explicit list of paths.
+
+ Parameters
+ ----------
+ urlpath: string or list
+ Absolute or relative filepath(s). Prefix with a protocol like ``s3://``
+ to read from alternative filesystems. To read from multiple files you
+ can pass a globstring or a list of paths, with the caveat that they
+ must all have the same protocol.
+ mode: 'rb', 'wt', etc.
+ compression: string or None
+ If given, open file using compression codec. Can either be a compression
+ name (a key in ``fsspec.compression.compr``) or "infer" to guess the
+ compression from the filename suffix.
+ encoding: str
+ For text mode only
+ errors: None or str
+ Passed to TextIOWrapper in text mode
+ name_function: function or None
+ if opening a set of files for writing, those files do not yet exist,
+ so we need to generate their names by formatting the urlpath for
+ each sequence number
+ num: int [1]
+ if writing mode, number of files we expect to create (passed to
+ name+function)
+ protocol: str or None
+ If given, overrides the protocol found in the URL.
+ newline: bytes or None
+ Used for line terminator in text mode. If None, uses system default;
+ if blank, uses no translation.
+ auto_mkdir: bool (True)
+ If in write mode, this will ensure the target directory exists before
+ writing, by calling ``fs.mkdirs(exist_ok=True)``.
+ expand: bool
+ **kwargs: dict
+ Extra options that make sense to a particular storage connection, e.g.
+ host, port, username, password, etc.
+
+ Examples
+ --------
+ >>> files = open_files('2015-*-*.csv') # doctest: +SKIP
+ >>> files = open_files(
+ ... 's3://bucket/2015-*-*.csv.gz', compression='gzip'
+ ... ) # doctest: +SKIP
+
+ Returns
+ -------
+ An ``OpenFiles`` instance, which is a list of ``OpenFile`` objects that can
+ be used as a single context
+
+ Notes
+ -----
+ For a full list of the available protocols and the implementations that
+ they map across to see the latest online documentation:
+
+ - For implementations built into ``fsspec`` see
+ https://filesystem-spec.readthedocs.io/en/latest/api.html#built-in-implementations
+ - For implementations in separate packages see
+ https://filesystem-spec.readthedocs.io/en/latest/api.html#other-known-implementations
+ """
+ fs, fs_token, paths = get_fs_token_paths(
+ urlpath,
+ mode,
+ num=num,
+ name_function=name_function,
+ storage_options=kwargs,
+ protocol=protocol,
+ expand=expand,
+ )
+ if fs.protocol == "file":
+ fs.auto_mkdir = auto_mkdir
+ elif "r" not in mode and auto_mkdir:
+ parents = {fs._parent(path) for path in paths}
+ for parent in parents:
+ try:
+ fs.makedirs(parent, exist_ok=True)
+ except PermissionError:
+ pass
+ return OpenFiles(
+ [
+ OpenFile(
+ fs,
+ path,
+ mode=mode,
+ compression=compression,
+ encoding=encoding,
+ errors=errors,
+ newline=newline,
+ )
+ for path in paths
+ ],
+ mode=mode,
+ fs=fs,
+ )
+
+
+def _un_chain(path, kwargs):
+ x = re.compile(".*[^a-z]+.*") # test for non protocol-like single word
+ bits = (
+ [p if "://" in p or x.match(p) else p + "://" for p in path.split("::")]
+ if "::" in path
+ else [path]
+ )
+ # [[url, protocol, kwargs], ...]
+ out = []
+ previous_bit = None
+ kwargs = kwargs.copy()
+ for bit in reversed(bits):
+ protocol = kwargs.pop("protocol", None) or split_protocol(bit)[0] or "file"
+ cls = get_filesystem_class(protocol)
+ extra_kwargs = cls._get_kwargs_from_urls(bit)
+ kws = kwargs.pop(protocol, {})
+ if bit is bits[0]:
+ kws.update(kwargs)
+ kw = dict(**extra_kwargs, **kws)
+ bit = cls._strip_protocol(bit)
+ if (
+ protocol in {"blockcache", "filecache", "simplecache"}
+ and "target_protocol" not in kw
+ ):
+ bit = previous_bit
+ out.append((bit, protocol, kw))
+ previous_bit = bit
+ out.reverse()
+ return out
+
+
+def url_to_fs(url, **kwargs):
+ """
+ Turn fully-qualified and potentially chained URL into filesystem instance
+
+ Parameters
+ ----------
+ url : str
+ The fsspec-compatible URL
+ **kwargs: dict
+ Extra options that make sense to a particular storage connection, e.g.
+ host, port, username, password, etc.
+
+ Returns
+ -------
+ filesystem : FileSystem
+ The new filesystem discovered from ``url`` and created with
+ ``**kwargs``.
+ urlpath : str
+ The file-systems-specific URL for ``url``.
+ """
+ url = stringify_path(url)
+ # non-FS arguments that appear in fsspec.open()
+ # inspect could keep this in sync with open()'s signature
+ known_kwargs = {
+ "compression",
+ "encoding",
+ "errors",
+ "expand",
+ "mode",
+ "name_function",
+ "newline",
+ "num",
+ }
+ kwargs = {k: v for k, v in kwargs.items() if k not in known_kwargs}
+ chain = _un_chain(url, kwargs)
+ inkwargs = {}
+ # Reverse iterate the chain, creating a nested target_* structure
+ for i, ch in enumerate(reversed(chain)):
+ urls, protocol, kw = ch
+ if i == len(chain) - 1:
+ inkwargs = dict(**kw, **inkwargs)
+ continue
+ inkwargs["target_options"] = dict(**kw, **inkwargs)
+ inkwargs["target_protocol"] = protocol
+ inkwargs["fo"] = urls
+ urlpath, protocol, _ = chain[0]
+ fs = filesystem(protocol, **inkwargs)
+ return fs, urlpath
+
+
+DEFAULT_EXPAND = conf.get("open_expand", False)
+
+
+def open(
+ urlpath,
+ mode="rb",
+ compression=None,
+ encoding="utf8",
+ errors=None,
+ protocol=None,
+ newline=None,
+ expand=None,
+ **kwargs,
+):
+ """Given a path or paths, return one ``OpenFile`` object.
+
+ Parameters
+ ----------
+ urlpath: string or list
+ Absolute or relative filepath. Prefix with a protocol like ``s3://``
+ to read from alternative filesystems. Should not include glob
+ character(s).
+ mode: 'rb', 'wt', etc.
+ compression: string or None
+ If given, open file using compression codec. Can either be a compression
+ name (a key in ``fsspec.compression.compr``) or "infer" to guess the
+ compression from the filename suffix.
+ encoding: str
+ For text mode only
+ errors: None or str
+ Passed to TextIOWrapper in text mode
+ protocol: str or None
+ If given, overrides the protocol found in the URL.
+ newline: bytes or None
+ Used for line terminator in text mode. If None, uses system default;
+ if blank, uses no translation.
+ expand: bool or Nonw
+ Whether to regard file paths containing special glob characters as needing
+ expansion (finding the first match) or absolute. Setting False allows using
+ paths which do embed such characters. If None (default), this argument
+ takes its value from the DEFAULT_EXPAND module variable, which takes
+ its initial value from the "open_expand" config value at startup, which will
+ be False if not set.
+ **kwargs: dict
+ Extra options that make sense to a particular storage connection, e.g.
+ host, port, username, password, etc.
+
+ Examples
+ --------
+ >>> openfile = open('2015-01-01.csv') # doctest: +SKIP
+ >>> openfile = open(
+ ... 's3://bucket/2015-01-01.csv.gz', compression='gzip'
+ ... ) # doctest: +SKIP
+ >>> with openfile as f:
+ ... df = pd.read_csv(f) # doctest: +SKIP
+ ...
+
+ Returns
+ -------
+ ``OpenFile`` object.
+
+ Notes
+ -----
+ For a full list of the available protocols and the implementations that
+ they map across to see the latest online documentation:
+
+ - For implementations built into ``fsspec`` see
+ https://filesystem-spec.readthedocs.io/en/latest/api.html#built-in-implementations
+ - For implementations in separate packages see
+ https://filesystem-spec.readthedocs.io/en/latest/api.html#other-known-implementations
+ """
+ expand = DEFAULT_EXPAND if expand is None else expand
+ out = open_files(
+ urlpath=[urlpath],
+ mode=mode,
+ compression=compression,
+ encoding=encoding,
+ errors=errors,
+ protocol=protocol,
+ newline=newline,
+ expand=expand,
+ **kwargs,
+ )
+ if not out:
+ raise FileNotFoundError(urlpath)
+ return out[0]
+
+
+def open_local(
+ url: str | list[str] | Path | list[Path],
+ mode: str = "rb",
+ **storage_options: dict,
+) -> str | list[str]:
+ """Open file(s) which can be resolved to local
+
+ For files which either are local, or get downloaded upon open
+ (e.g., by file caching)
+
+ Parameters
+ ----------
+ url: str or list(str)
+ mode: str
+ Must be read mode
+ storage_options:
+ passed on to FS for or used by open_files (e.g., compression)
+ """
+ if "r" not in mode:
+ raise ValueError("Can only ensure local files when reading")
+ of = open_files(url, mode=mode, **storage_options)
+ if not getattr(of[0].fs, "local_file", False):
+ raise ValueError(
+ "open_local can only be used on a filesystem which"
+ " has attribute local_file=True"
+ )
+ with of as files:
+ paths = [f.name for f in files]
+ if (isinstance(url, str) and not has_magic(url)) or isinstance(url, Path):
+ return paths[0]
+ return paths
+
+
+def get_compression(urlpath, compression):
+ if compression == "infer":
+ compression = infer_compression(urlpath)
+ if compression is not None and compression not in compr:
+ raise ValueError(f"Compression type {compression} not supported")
+ return compression
+
+
+def split_protocol(urlpath):
+ """Return protocol, path pair"""
+ urlpath = stringify_path(urlpath)
+ if "://" in urlpath:
+ protocol, path = urlpath.split("://", 1)
+ if len(protocol) > 1:
+ # excludes Windows paths
+ return protocol, path
+ if urlpath.startswith("data:"):
+ return urlpath.split(":", 1)
+ return None, urlpath
+
+
+def strip_protocol(urlpath):
+ """Return only path part of full URL, according to appropriate backend"""
+ protocol, _ = split_protocol(urlpath)
+ cls = get_filesystem_class(protocol)
+ return cls._strip_protocol(urlpath)
+
+
+def expand_paths_if_needed(paths, mode, num, fs, name_function):
+ """Expand paths if they have a ``*`` in them (write mode) or any of ``*?[]``
+ in them (read mode).
+
+ :param paths: list of paths
+ mode: str
+ Mode in which to open files.
+ num: int
+ If opening in writing mode, number of files we expect to create.
+ fs: filesystem object
+ name_function: callable
+ If opening in writing mode, this callable is used to generate path
+ names. Names are generated for each partition by
+ ``urlpath.replace('*', name_function(partition_index))``.
+ :return: list of paths
+ """
+ expanded_paths = []
+ paths = list(paths)
+
+ if "w" in mode: # read mode
+ if sum([1 for p in paths if "*" in p]) > 1:
+ raise ValueError(
+ "When writing data, only one filename mask can be specified."
+ )
+ num = max(num, len(paths))
+
+ for curr_path in paths:
+ if "*" in curr_path:
+ # expand using name_function
+ expanded_paths.extend(_expand_paths(curr_path, name_function, num))
+ else:
+ expanded_paths.append(curr_path)
+ # if we generated more paths that asked for, trim the list
+ if len(expanded_paths) > num:
+ expanded_paths = expanded_paths[:num]
+
+ else: # read mode
+ for curr_path in paths:
+ if has_magic(curr_path):
+ # expand using glob
+ expanded_paths.extend(fs.glob(curr_path))
+ else:
+ expanded_paths.append(curr_path)
+
+ return expanded_paths
+
+
+def get_fs_token_paths(
+ urlpath,
+ mode="rb",
+ num=1,
+ name_function=None,
+ storage_options=None,
+ protocol=None,
+ expand=True,
+):
+ """Filesystem, deterministic token, and paths from a urlpath and options.
+
+ Parameters
+ ----------
+ urlpath: string or iterable
+ Absolute or relative filepath, URL (may include protocols like
+ ``s3://``), or globstring pointing to data.
+ mode: str, optional
+ Mode in which to open files.
+ num: int, optional
+ If opening in writing mode, number of files we expect to create.
+ name_function: callable, optional
+ If opening in writing mode, this callable is used to generate path
+ names. Names are generated for each partition by
+ ``urlpath.replace('*', name_function(partition_index))``.
+ storage_options: dict, optional
+ Additional keywords to pass to the filesystem class.
+ protocol: str or None
+ To override the protocol specifier in the URL
+ expand: bool
+ Expand string paths for writing, assuming the path is a directory
+ """
+ if isinstance(urlpath, (list, tuple, set)):
+ if not urlpath:
+ raise ValueError("empty urlpath sequence")
+ urlpath0 = stringify_path(list(urlpath)[0])
+ else:
+ urlpath0 = stringify_path(urlpath)
+ storage_options = storage_options or {}
+ if protocol:
+ storage_options["protocol"] = protocol
+ chain = _un_chain(urlpath0, storage_options or {})
+ inkwargs = {}
+ # Reverse iterate the chain, creating a nested target_* structure
+ for i, ch in enumerate(reversed(chain)):
+ urls, nested_protocol, kw = ch
+ if i == len(chain) - 1:
+ inkwargs = dict(**kw, **inkwargs)
+ continue
+ inkwargs["target_options"] = dict(**kw, **inkwargs)
+ inkwargs["target_protocol"] = nested_protocol
+ inkwargs["fo"] = urls
+ paths, protocol, _ = chain[0]
+ fs = filesystem(protocol, **inkwargs)
+ if isinstance(urlpath, (list, tuple, set)):
+ pchains = [
+ _un_chain(stringify_path(u), storage_options or {})[0] for u in urlpath
+ ]
+ if len({pc[1] for pc in pchains}) > 1:
+ raise ValueError("Protocol mismatch getting fs from %s", urlpath)
+ paths = [pc[0] for pc in pchains]
+ else:
+ paths = fs._strip_protocol(paths)
+ if isinstance(paths, (list, tuple, set)):
+ if expand:
+ paths = expand_paths_if_needed(paths, mode, num, fs, name_function)
+ elif not isinstance(paths, list):
+ paths = list(paths)
+ else:
+ if "w" in mode and expand:
+ paths = _expand_paths(paths, name_function, num)
+ elif "x" in mode and expand:
+ paths = _expand_paths(paths, name_function, num)
+ elif "*" in paths:
+ paths = [f for f in sorted(fs.glob(paths)) if not fs.isdir(f)]
+ else:
+ paths = [paths]
+
+ return fs, fs._fs_token, paths
+
+
+def _expand_paths(path, name_function, num):
+ if isinstance(path, str):
+ if path.count("*") > 1:
+ raise ValueError("Output path spec must contain exactly one '*'.")
+ elif "*" not in path:
+ path = os.path.join(path, "*.part")
+
+ if name_function is None:
+ name_function = build_name_function(num - 1)
+
+ paths = [path.replace("*", name_function(i)) for i in range(num)]
+ if paths != sorted(paths):
+ logger.warning(
+ "In order to preserve order between partitions"
+ " paths created with ``name_function`` should "
+ "sort to partition order"
+ )
+ elif isinstance(path, (tuple, list)):
+ assert len(path) == num
+ paths = list(path)
+ else:
+ raise ValueError(
+ "Path should be either\n"
+ "1. A list of paths: ['foo.json', 'bar.json', ...]\n"
+ "2. A directory: 'foo/\n"
+ "3. A path with a '*' in it: 'foo.*.json'"
+ )
+ return paths
+
+
+class PickleableTextIOWrapper(io.TextIOWrapper):
+ """TextIOWrapper cannot be pickled. This solves it.
+
+ Requires that ``buffer`` be pickleable, which all instances of
+ AbstractBufferedFile are.
+ """
+
+ def __init__(
+ self,
+ buffer,
+ encoding=None,
+ errors=None,
+ newline=None,
+ line_buffering=False,
+ write_through=False,
+ ):
+ self.args = buffer, encoding, errors, newline, line_buffering, write_through
+ super().__init__(*self.args)
+
+ def __reduce__(self):
+ return PickleableTextIOWrapper, self.args
diff --git a/parrot/lib/python3.10/site-packages/fsspec/dircache.py b/parrot/lib/python3.10/site-packages/fsspec/dircache.py
new file mode 100644
index 0000000000000000000000000000000000000000..eca19566b135e5a7a4f6e7407d56411ec58bfe44
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/fsspec/dircache.py
@@ -0,0 +1,98 @@
+import time
+from collections.abc import MutableMapping
+from functools import lru_cache
+
+
+class DirCache(MutableMapping):
+ """
+ Caching of directory listings, in a structure like::
+
+ {"path0": [
+ {"name": "path0/file0",
+ "size": 123,
+ "type": "file",
+ ...
+ },
+ {"name": "path0/file1",
+ },
+ ...
+ ],
+ "path1": [...]
+ }
+
+ Parameters to this class control listing expiry or indeed turn
+ caching off
+ """
+
+ def __init__(
+ self,
+ use_listings_cache=True,
+ listings_expiry_time=None,
+ max_paths=None,
+ **kwargs,
+ ):
+ """
+
+ Parameters
+ ----------
+ use_listings_cache: bool
+ If False, this cache never returns items, but always reports KeyError,
+ and setting items has no effect
+ listings_expiry_time: int or float (optional)
+ Time in seconds that a listing is considered valid. If None,
+ listings do not expire.
+ max_paths: int (optional)
+ The number of most recent listings that are considered valid; 'recent'
+ refers to when the entry was set.
+ """
+ self._cache = {}
+ self._times = {}
+ if max_paths:
+ self._q = lru_cache(max_paths + 1)(lambda key: self._cache.pop(key, None))
+ self.use_listings_cache = use_listings_cache
+ self.listings_expiry_time = listings_expiry_time
+ self.max_paths = max_paths
+
+ def __getitem__(self, item):
+ if self.listings_expiry_time is not None:
+ if self._times.get(item, 0) - time.time() < -self.listings_expiry_time:
+ del self._cache[item]
+ if self.max_paths:
+ self._q(item)
+ return self._cache[item] # maybe raises KeyError
+
+ def clear(self):
+ self._cache.clear()
+
+ def __len__(self):
+ return len(self._cache)
+
+ def __contains__(self, item):
+ try:
+ self[item]
+ return True
+ except KeyError:
+ return False
+
+ def __setitem__(self, key, value):
+ if not self.use_listings_cache:
+ return
+ if self.max_paths:
+ self._q(key)
+ self._cache[key] = value
+ if self.listings_expiry_time is not None:
+ self._times[key] = time.time()
+
+ def __delitem__(self, key):
+ del self._cache[key]
+
+ def __iter__(self):
+ entries = list(self._cache)
+
+ return (k for k in entries if k in self)
+
+ def __reduce__(self):
+ return (
+ DirCache,
+ (self.use_listings_cache, self.listings_expiry_time, self.max_paths),
+ )
diff --git a/parrot/lib/python3.10/site-packages/fsspec/exceptions.py b/parrot/lib/python3.10/site-packages/fsspec/exceptions.py
new file mode 100644
index 0000000000000000000000000000000000000000..ae8905475f02655f4fc5863931d99ca9da55db78
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/fsspec/exceptions.py
@@ -0,0 +1,18 @@
+"""
+fsspec user-defined exception classes
+"""
+
+import asyncio
+
+
+class BlocksizeMismatchError(ValueError):
+ """
+ Raised when a cached file is opened with a different blocksize than it was
+ written with
+ """
+
+
+class FSTimeoutError(asyncio.TimeoutError):
+ """
+ Raised when a fsspec function timed out occurs
+ """
diff --git a/parrot/lib/python3.10/site-packages/fsspec/fuse.py b/parrot/lib/python3.10/site-packages/fsspec/fuse.py
new file mode 100644
index 0000000000000000000000000000000000000000..6ca8c973c1993ac00016bb46e3ae7a3e44bc8d15
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/fsspec/fuse.py
@@ -0,0 +1,324 @@
+import argparse
+import logging
+import os
+import stat
+import threading
+import time
+from errno import EIO, ENOENT
+
+from fuse import FUSE, FuseOSError, LoggingMixIn, Operations
+
+from fsspec import __version__
+from fsspec.core import url_to_fs
+
+logger = logging.getLogger("fsspec.fuse")
+
+
+class FUSEr(Operations):
+ def __init__(self, fs, path, ready_file=False):
+ self.fs = fs
+ self.cache = {}
+ self.root = path.rstrip("/") + "/"
+ self.counter = 0
+ logger.info("Starting FUSE at %s", path)
+ self._ready_file = ready_file
+
+ def getattr(self, path, fh=None):
+ logger.debug("getattr %s", path)
+ if self._ready_file and path in ["/.fuse_ready", ".fuse_ready"]:
+ return {"type": "file", "st_size": 5}
+
+ path = "".join([self.root, path.lstrip("/")]).rstrip("/")
+ try:
+ info = self.fs.info(path)
+ except FileNotFoundError:
+ raise FuseOSError(ENOENT)
+
+ data = {"st_uid": info.get("uid", 1000), "st_gid": info.get("gid", 1000)}
+ perm = info.get("mode", 0o777)
+
+ if info["type"] != "file":
+ data["st_mode"] = stat.S_IFDIR | perm
+ data["st_size"] = 0
+ data["st_blksize"] = 0
+ else:
+ data["st_mode"] = stat.S_IFREG | perm
+ data["st_size"] = info["size"]
+ data["st_blksize"] = 5 * 2**20
+ data["st_nlink"] = 1
+ data["st_atime"] = info["atime"] if "atime" in info else time.time()
+ data["st_ctime"] = info["ctime"] if "ctime" in info else time.time()
+ data["st_mtime"] = info["mtime"] if "mtime" in info else time.time()
+ return data
+
+ def readdir(self, path, fh):
+ logger.debug("readdir %s", path)
+ path = "".join([self.root, path.lstrip("/")])
+ files = self.fs.ls(path, False)
+ files = [os.path.basename(f.rstrip("/")) for f in files]
+ return [".", ".."] + files
+
+ def mkdir(self, path, mode):
+ path = "".join([self.root, path.lstrip("/")])
+ self.fs.mkdir(path)
+ return 0
+
+ def rmdir(self, path):
+ path = "".join([self.root, path.lstrip("/")])
+ self.fs.rmdir(path)
+ return 0
+
+ def read(self, path, size, offset, fh):
+ logger.debug("read %s", (path, size, offset))
+ if self._ready_file and path in ["/.fuse_ready", ".fuse_ready"]:
+ # status indicator
+ return b"ready"
+
+ f = self.cache[fh]
+ f.seek(offset)
+ out = f.read(size)
+ return out
+
+ def write(self, path, data, offset, fh):
+ logger.debug("write %s", (path, offset))
+ f = self.cache[fh]
+ f.seek(offset)
+ f.write(data)
+ return len(data)
+
+ def create(self, path, flags, fi=None):
+ logger.debug("create %s", (path, flags))
+ fn = "".join([self.root, path.lstrip("/")])
+ self.fs.touch(fn) # OS will want to get attributes immediately
+ f = self.fs.open(fn, "wb")
+ self.cache[self.counter] = f
+ self.counter += 1
+ return self.counter - 1
+
+ def open(self, path, flags):
+ logger.debug("open %s", (path, flags))
+ fn = "".join([self.root, path.lstrip("/")])
+ if flags % 2 == 0:
+ # read
+ mode = "rb"
+ else:
+ # write/create
+ mode = "wb"
+ self.cache[self.counter] = self.fs.open(fn, mode)
+ self.counter += 1
+ return self.counter - 1
+
+ def truncate(self, path, length, fh=None):
+ fn = "".join([self.root, path.lstrip("/")])
+ if length != 0:
+ raise NotImplementedError
+ # maybe should be no-op since open with write sets size to zero anyway
+ self.fs.touch(fn)
+
+ def unlink(self, path):
+ fn = "".join([self.root, path.lstrip("/")])
+ try:
+ self.fs.rm(fn, False)
+ except (OSError, FileNotFoundError):
+ raise FuseOSError(EIO)
+
+ def release(self, path, fh):
+ try:
+ if fh in self.cache:
+ f = self.cache[fh]
+ f.close()
+ self.cache.pop(fh)
+ except Exception as e:
+ print(e)
+ return 0
+
+ def chmod(self, path, mode):
+ if hasattr(self.fs, "chmod"):
+ path = "".join([self.root, path.lstrip("/")])
+ return self.fs.chmod(path, mode)
+ raise NotImplementedError
+
+
+def run(
+ fs,
+ path,
+ mount_point,
+ foreground=True,
+ threads=False,
+ ready_file=False,
+ ops_class=FUSEr,
+):
+ """Mount stuff in a local directory
+
+ This uses fusepy to make it appear as if a given path on an fsspec
+ instance is in fact resident within the local file-system.
+
+ This requires that fusepy by installed, and that FUSE be available on
+ the system (typically requiring a package to be installed with
+ apt, yum, brew, etc.).
+
+ Parameters
+ ----------
+ fs: file-system instance
+ From one of the compatible implementations
+ path: str
+ Location on that file-system to regard as the root directory to
+ mount. Note that you typically should include the terminating "/"
+ character.
+ mount_point: str
+ An empty directory on the local file-system where the contents of
+ the remote path will appear.
+ foreground: bool
+ Whether or not calling this function will block. Operation will
+ typically be more stable if True.
+ threads: bool
+ Whether or not to create threads when responding to file operations
+ within the mounter directory. Operation will typically be more
+ stable if False.
+ ready_file: bool
+ Whether the FUSE process is ready. The ``.fuse_ready`` file will
+ exist in the ``mount_point`` directory if True. Debugging purpose.
+ ops_class: FUSEr or Subclass of FUSEr
+ To override the default behavior of FUSEr. For Example, logging
+ to file.
+
+ """
+ func = lambda: FUSE(
+ ops_class(fs, path, ready_file=ready_file),
+ mount_point,
+ nothreads=not threads,
+ foreground=foreground,
+ )
+ if not foreground:
+ th = threading.Thread(target=func)
+ th.daemon = True
+ th.start()
+ return th
+ else: # pragma: no cover
+ try:
+ func()
+ except KeyboardInterrupt:
+ pass
+
+
+def main(args):
+ """Mount filesystem from chained URL to MOUNT_POINT.
+
+ Examples:
+
+ python3 -m fsspec.fuse memory /usr/share /tmp/mem
+
+ python3 -m fsspec.fuse local /tmp/source /tmp/local \\
+ -l /tmp/fsspecfuse.log
+
+ You can also mount chained-URLs and use special settings:
+
+ python3 -m fsspec.fuse 'filecache::zip::file://data.zip' \\
+ / /tmp/zip \\
+ -o 'filecache-cache_storage=/tmp/simplecache'
+
+ You can specify the type of the setting by using `[int]` or `[bool]`,
+ (`true`, `yes`, `1` represents the Boolean value `True`):
+
+ python3 -m fsspec.fuse 'simplecache::ftp://ftp1.at.proftpd.org' \\
+ /historic/packages/RPMS /tmp/ftp \\
+ -o 'simplecache-cache_storage=/tmp/simplecache' \\
+ -o 'simplecache-check_files=false[bool]' \\
+ -o 'ftp-listings_expiry_time=60[int]' \\
+ -o 'ftp-username=anonymous' \\
+ -o 'ftp-password=xieyanbo'
+ """
+
+ class RawDescriptionArgumentParser(argparse.ArgumentParser):
+ def format_help(self):
+ usage = super().format_help()
+ parts = usage.split("\n\n")
+ parts[1] = self.description.rstrip()
+ return "\n\n".join(parts)
+
+ parser = RawDescriptionArgumentParser(prog="fsspec.fuse", description=main.__doc__)
+ parser.add_argument("--version", action="version", version=__version__)
+ parser.add_argument("url", type=str, help="fs url")
+ parser.add_argument("source_path", type=str, help="source directory in fs")
+ parser.add_argument("mount_point", type=str, help="local directory")
+ parser.add_argument(
+ "-o",
+ "--option",
+ action="append",
+ help="Any options of protocol included in the chained URL",
+ )
+ parser.add_argument(
+ "-l", "--log-file", type=str, help="Logging FUSE debug info (Default: '')"
+ )
+ parser.add_argument(
+ "-f",
+ "--foreground",
+ action="store_false",
+ help="Running in foreground or not (Default: False)",
+ )
+ parser.add_argument(
+ "-t",
+ "--threads",
+ action="store_false",
+ help="Running with threads support (Default: False)",
+ )
+ parser.add_argument(
+ "-r",
+ "--ready-file",
+ action="store_false",
+ help="The `.fuse_ready` file will exist after FUSE is ready. "
+ "(Debugging purpose, Default: False)",
+ )
+ args = parser.parse_args(args)
+
+ kwargs = {}
+ for item in args.option or []:
+ key, sep, value = item.partition("=")
+ if not sep:
+ parser.error(message=f"Wrong option: {item!r}")
+ val = value.lower()
+ if val.endswith("[int]"):
+ value = int(value[: -len("[int]")])
+ elif val.endswith("[bool]"):
+ value = val[: -len("[bool]")] in ["1", "yes", "true"]
+
+ if "-" in key:
+ fs_name, setting_name = key.split("-", 1)
+ if fs_name in kwargs:
+ kwargs[fs_name][setting_name] = value
+ else:
+ kwargs[fs_name] = {setting_name: value}
+ else:
+ kwargs[key] = value
+
+ if args.log_file:
+ logging.basicConfig(
+ level=logging.DEBUG,
+ filename=args.log_file,
+ format="%(asctime)s %(message)s",
+ )
+
+ class LoggingFUSEr(FUSEr, LoggingMixIn):
+ pass
+
+ fuser = LoggingFUSEr
+ else:
+ fuser = FUSEr
+
+ fs, url_path = url_to_fs(args.url, **kwargs)
+ logger.debug("Mounting %s to %s", url_path, str(args.mount_point))
+ run(
+ fs,
+ args.source_path,
+ args.mount_point,
+ foreground=args.foreground,
+ threads=args.threads,
+ ready_file=args.ready_file,
+ ops_class=fuser,
+ )
+
+
+if __name__ == "__main__":
+ import sys
+
+ main(sys.argv[1:])
diff --git a/parrot/lib/python3.10/site-packages/fsspec/generic.py b/parrot/lib/python3.10/site-packages/fsspec/generic.py
new file mode 100644
index 0000000000000000000000000000000000000000..9bad0f048f737400b4cd919f7699d15fbfbf7c62
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/fsspec/generic.py
@@ -0,0 +1,411 @@
+from __future__ import annotations
+
+import inspect
+import logging
+import os
+import shutil
+import uuid
+from typing import Optional
+
+from .asyn import AsyncFileSystem, _run_coros_in_chunks, sync_wrapper
+from .callbacks import DEFAULT_CALLBACK
+from .core import filesystem, get_filesystem_class, split_protocol, url_to_fs
+
+_generic_fs = {}
+logger = logging.getLogger("fsspec.generic")
+
+
+def set_generic_fs(protocol, **storage_options):
+ _generic_fs[protocol] = filesystem(protocol, **storage_options)
+
+
+default_method = "default"
+
+
+def _resolve_fs(url, method=None, protocol=None, storage_options=None):
+ """Pick instance of backend FS"""
+ method = method or default_method
+ protocol = protocol or split_protocol(url)[0]
+ storage_options = storage_options or {}
+ if method == "default":
+ return filesystem(protocol)
+ if method == "generic":
+ return _generic_fs[protocol]
+ if method == "current":
+ cls = get_filesystem_class(protocol)
+ return cls.current()
+ if method == "options":
+ fs, _ = url_to_fs(url, **storage_options.get(protocol, {}))
+ return fs
+ raise ValueError(f"Unknown FS resolution method: {method}")
+
+
+def rsync(
+ source,
+ destination,
+ delete_missing=False,
+ source_field="size",
+ dest_field="size",
+ update_cond="different",
+ inst_kwargs=None,
+ fs=None,
+ **kwargs,
+):
+ """Sync files between two directory trees
+
+ (experimental)
+
+ Parameters
+ ----------
+ source: str
+ Root of the directory tree to take files from. This must be a directory, but
+ do not include any terminating "/" character
+ destination: str
+ Root path to copy into. The contents of this location should be
+ identical to the contents of ``source`` when done. This will be made a
+ directory, and the terminal "/" should not be included.
+ delete_missing: bool
+ If there are paths in the destination that don't exist in the
+ source and this is True, delete them. Otherwise, leave them alone.
+ source_field: str | callable
+ If ``update_field`` is "different", this is the key in the info
+ of source files to consider for difference. Maybe a function of the
+ info dict.
+ dest_field: str | callable
+ If ``update_field`` is "different", this is the key in the info
+ of destination files to consider for difference. May be a function of
+ the info dict.
+ update_cond: "different"|"always"|"never"
+ If "always", every file is copied, regardless of whether it exists in
+ the destination. If "never", files that exist in the destination are
+ not copied again. If "different" (default), only copy if the info
+ fields given by ``source_field`` and ``dest_field`` (usually "size")
+ are different. Other comparisons may be added in the future.
+ inst_kwargs: dict|None
+ If ``fs`` is None, use this set of keyword arguments to make a
+ GenericFileSystem instance
+ fs: GenericFileSystem|None
+ Instance to use if explicitly given. The instance defines how to
+ to make downstream file system instances from paths.
+
+ Returns
+ -------
+ dict of the copy operations that were performed, {source: destination}
+ """
+ fs = fs or GenericFileSystem(**(inst_kwargs or {}))
+ source = fs._strip_protocol(source)
+ destination = fs._strip_protocol(destination)
+ allfiles = fs.find(source, withdirs=True, detail=True)
+ if not fs.isdir(source):
+ raise ValueError("Can only rsync on a directory")
+ otherfiles = fs.find(destination, withdirs=True, detail=True)
+ dirs = [
+ a
+ for a, v in allfiles.items()
+ if v["type"] == "directory" and a.replace(source, destination) not in otherfiles
+ ]
+ logger.debug(f"{len(dirs)} directories to create")
+ if dirs:
+ fs.make_many_dirs(
+ [dirn.replace(source, destination) for dirn in dirs], exist_ok=True
+ )
+ allfiles = {a: v for a, v in allfiles.items() if v["type"] == "file"}
+ logger.debug(f"{len(allfiles)} files to consider for copy")
+ to_delete = [
+ o
+ for o, v in otherfiles.items()
+ if o.replace(destination, source) not in allfiles and v["type"] == "file"
+ ]
+ for k, v in allfiles.copy().items():
+ otherfile = k.replace(source, destination)
+ if otherfile in otherfiles:
+ if update_cond == "always":
+ allfiles[k] = otherfile
+ elif update_cond == "different":
+ inf1 = source_field(v) if callable(source_field) else v[source_field]
+ v2 = otherfiles[otherfile]
+ inf2 = dest_field(v2) if callable(dest_field) else v2[dest_field]
+ if inf1 != inf2:
+ # details mismatch, make copy
+ allfiles[k] = otherfile
+ else:
+ # details match, don't copy
+ allfiles.pop(k)
+ else:
+ # file not in target yet
+ allfiles[k] = otherfile
+ logger.debug(f"{len(allfiles)} files to copy")
+ if allfiles:
+ source_files, target_files = zip(*allfiles.items())
+ fs.cp(source_files, target_files, **kwargs)
+ logger.debug(f"{len(to_delete)} files to delete")
+ if delete_missing and to_delete:
+ fs.rm(to_delete)
+ return allfiles
+
+
+class GenericFileSystem(AsyncFileSystem):
+ """Wrapper over all other FS types
+
+
+
+ This implementation is a single unified interface to be able to run FS operations
+ over generic URLs, and dispatch to the specific implementations using the URL
+ protocol prefix.
+
+ Note: instances of this FS are always async, even if you never use it with any async
+ backend.
+ """
+
+ protocol = "generic" # there is no real reason to ever use a protocol with this FS
+
+ def __init__(self, default_method="default", **kwargs):
+ """
+
+ Parameters
+ ----------
+ default_method: str (optional)
+ Defines how to configure backend FS instances. Options are:
+ - "default": instantiate like FSClass(), with no
+ extra arguments; this is the default instance of that FS, and can be
+ configured via the config system
+ - "generic": takes instances from the `_generic_fs` dict in this module,
+ which you must populate before use. Keys are by protocol
+ - "current": takes the most recently instantiated version of each FS
+ """
+ self.method = default_method
+ super().__init__(**kwargs)
+
+ def _parent(self, path):
+ fs = _resolve_fs(path, self.method)
+ return fs.unstrip_protocol(fs._parent(path))
+
+ def _strip_protocol(self, path):
+ # normalization only
+ fs = _resolve_fs(path, self.method)
+ return fs.unstrip_protocol(fs._strip_protocol(path))
+
+ async def _find(self, path, maxdepth=None, withdirs=False, detail=False, **kwargs):
+ fs = _resolve_fs(path, self.method)
+ if fs.async_impl:
+ out = await fs._find(
+ path, maxdepth=maxdepth, withdirs=withdirs, detail=True, **kwargs
+ )
+ else:
+ out = fs.find(
+ path, maxdepth=maxdepth, withdirs=withdirs, detail=True, **kwargs
+ )
+ result = {}
+ for k, v in out.items():
+ v = v.copy() # don't corrupt target FS dircache
+ name = fs.unstrip_protocol(k)
+ v["name"] = name
+ result[name] = v
+ if detail:
+ return result
+ return list(result)
+
+ async def _info(self, url, **kwargs):
+ fs = _resolve_fs(url, self.method)
+ if fs.async_impl:
+ out = await fs._info(url, **kwargs)
+ else:
+ out = fs.info(url, **kwargs)
+ out = out.copy() # don't edit originals
+ out["name"] = fs.unstrip_protocol(out["name"])
+ return out
+
+ async def _ls(
+ self,
+ url,
+ detail=True,
+ **kwargs,
+ ):
+ fs = _resolve_fs(url, self.method)
+ if fs.async_impl:
+ out = await fs._ls(url, detail=True, **kwargs)
+ else:
+ out = fs.ls(url, detail=True, **kwargs)
+ out = [o.copy() for o in out] # don't edit originals
+ for o in out:
+ o["name"] = fs.unstrip_protocol(o["name"])
+ if detail:
+ return out
+ else:
+ return [o["name"] for o in out]
+
+ async def _cat_file(
+ self,
+ url,
+ **kwargs,
+ ):
+ fs = _resolve_fs(url, self.method)
+ if fs.async_impl:
+ return await fs._cat_file(url, **kwargs)
+ else:
+ return fs.cat_file(url, **kwargs)
+
+ async def _pipe_file(
+ self,
+ path,
+ value,
+ **kwargs,
+ ):
+ fs = _resolve_fs(path, self.method)
+ if fs.async_impl:
+ return await fs._pipe_file(path, value, **kwargs)
+ else:
+ return fs.pipe_file(path, value, **kwargs)
+
+ async def _rm(self, url, **kwargs):
+ urls = url
+ if isinstance(urls, str):
+ urls = [urls]
+ fs = _resolve_fs(urls[0], self.method)
+ if fs.async_impl:
+ await fs._rm(urls, **kwargs)
+ else:
+ fs.rm(url, **kwargs)
+
+ async def _makedirs(self, path, exist_ok=False):
+ logger.debug("Make dir %s", path)
+ fs = _resolve_fs(path, self.method)
+ if fs.async_impl:
+ await fs._makedirs(path, exist_ok=exist_ok)
+ else:
+ fs.makedirs(path, exist_ok=exist_ok)
+
+ def rsync(self, source, destination, **kwargs):
+ """Sync files between two directory trees
+
+ See `func:rsync` for more details.
+ """
+ rsync(source, destination, fs=self, **kwargs)
+
+ async def _cp_file(
+ self,
+ url,
+ url2,
+ blocksize=2**20,
+ callback=DEFAULT_CALLBACK,
+ **kwargs,
+ ):
+ fs = _resolve_fs(url, self.method)
+ fs2 = _resolve_fs(url2, self.method)
+ if fs is fs2:
+ # pure remote
+ if fs.async_impl:
+ return await fs._cp_file(url, url2, **kwargs)
+ else:
+ return fs.cp_file(url, url2, **kwargs)
+ kw = {"blocksize": 0, "cache_type": "none"}
+ try:
+ f1 = (
+ await fs.open_async(url, "rb")
+ if hasattr(fs, "open_async")
+ else fs.open(url, "rb", **kw)
+ )
+ callback.set_size(await maybe_await(f1.size))
+ f2 = (
+ await fs2.open_async(url2, "wb")
+ if hasattr(fs2, "open_async")
+ else fs2.open(url2, "wb", **kw)
+ )
+ while f1.size is None or f2.tell() < f1.size:
+ data = await maybe_await(f1.read(blocksize))
+ if f1.size is None and not data:
+ break
+ await maybe_await(f2.write(data))
+ callback.absolute_update(f2.tell())
+ finally:
+ try:
+ await maybe_await(f2.close())
+ await maybe_await(f1.close())
+ except NameError:
+ # fail while opening f1 or f2
+ pass
+
+ async def _make_many_dirs(self, urls, exist_ok=True):
+ fs = _resolve_fs(urls[0], self.method)
+ if fs.async_impl:
+ coros = [fs._makedirs(u, exist_ok=exist_ok) for u in urls]
+ await _run_coros_in_chunks(coros)
+ else:
+ for u in urls:
+ fs.makedirs(u, exist_ok=exist_ok)
+
+ make_many_dirs = sync_wrapper(_make_many_dirs)
+
+ async def _copy(
+ self,
+ path1: list[str],
+ path2: list[str],
+ recursive: bool = False,
+ on_error: str = "ignore",
+ maxdepth: Optional[int] = None,
+ batch_size: Optional[int] = None,
+ tempdir: Optional[str] = None,
+ **kwargs,
+ ):
+ if recursive:
+ raise NotImplementedError
+ fs = _resolve_fs(path1[0], self.method)
+ fs2 = _resolve_fs(path2[0], self.method)
+ # not expanding paths atm., assume call is from rsync()
+ if fs is fs2:
+ # pure remote
+ if fs.async_impl:
+ return await fs._copy(path1, path2, **kwargs)
+ else:
+ return fs.copy(path1, path2, **kwargs)
+ await copy_file_op(
+ fs, path1, fs2, path2, tempdir, batch_size, on_error=on_error
+ )
+
+
+async def copy_file_op(
+ fs1, url1, fs2, url2, tempdir=None, batch_size=20, on_error="ignore"
+):
+ import tempfile
+
+ tempdir = tempdir or tempfile.mkdtemp()
+ try:
+ coros = [
+ _copy_file_op(
+ fs1,
+ u1,
+ fs2,
+ u2,
+ os.path.join(tempdir, uuid.uuid4().hex),
+ on_error=on_error,
+ )
+ for u1, u2 in zip(url1, url2)
+ ]
+ await _run_coros_in_chunks(coros, batch_size=batch_size)
+ finally:
+ shutil.rmtree(tempdir)
+
+
+async def _copy_file_op(fs1, url1, fs2, url2, local, on_error="ignore"):
+ ex = () if on_error == "raise" else Exception
+ logger.debug("Copy %s -> %s", url1, url2)
+ try:
+ if fs1.async_impl:
+ await fs1._get_file(url1, local)
+ else:
+ fs1.get_file(url1, local)
+ if fs2.async_impl:
+ await fs2._put_file(local, url2)
+ else:
+ fs2.put_file(local, url2)
+ os.unlink(local)
+ logger.debug("Copy %s -> %s; done", url1, url2)
+ except ex as e:
+ logger.debug("ignoring cp exception for %s: %s", url1, e)
+
+
+async def maybe_await(cor):
+ if inspect.iscoroutine(cor):
+ return await cor
+ else:
+ return cor
diff --git a/parrot/lib/python3.10/site-packages/fsspec/gui.py b/parrot/lib/python3.10/site-packages/fsspec/gui.py
new file mode 100644
index 0000000000000000000000000000000000000000..113317e5a48c4d5fac062bc84019e97a05e16a0f
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/fsspec/gui.py
@@ -0,0 +1,414 @@
+import ast
+import contextlib
+import logging
+import os
+import re
+from typing import ClassVar, Sequence
+
+import panel as pn
+
+from .core import OpenFile, get_filesystem_class, split_protocol
+from .registry import known_implementations
+
+pn.extension()
+logger = logging.getLogger("fsspec.gui")
+
+
+class SigSlot:
+ """Signal-slot mixin, for Panel event passing
+
+ Include this class in a widget manager's superclasses to be able to
+ register events and callbacks on Panel widgets managed by that class.
+
+ The method ``_register`` should be called as widgets are added, and external
+ code should call ``connect`` to associate callbacks.
+
+ By default, all signals emit a DEBUG logging statement.
+ """
+
+ # names of signals that this class may emit each of which must be
+ # set by _register for any new instance
+ signals: ClassVar[Sequence[str]] = []
+ # names of actions that this class may respond to
+ slots: ClassVar[Sequence[str]] = []
+
+ # each of which must be a method name
+
+ def __init__(self):
+ self._ignoring_events = False
+ self._sigs = {}
+ self._map = {}
+ self._setup()
+
+ def _setup(self):
+ """Create GUI elements and register signals"""
+ self.panel = pn.pane.PaneBase()
+ # no signals to set up in the base class
+
+ def _register(
+ self, widget, name, thing="value", log_level=logging.DEBUG, auto=False
+ ):
+ """Watch the given attribute of a widget and assign it a named event
+
+ This is normally called at the time a widget is instantiated, in the
+ class which owns it.
+
+ Parameters
+ ----------
+ widget : pn.layout.Panel or None
+ Widget to watch. If None, an anonymous signal not associated with
+ any widget.
+ name : str
+ Name of this event
+ thing : str
+ Attribute of the given widget to watch
+ log_level : int
+ When the signal is triggered, a logging event of the given level
+ will be fired in the dfviz logger.
+ auto : bool
+ If True, automatically connects with a method in this class of the
+ same name.
+ """
+ if name not in self.signals:
+ raise ValueError(f"Attempt to assign an undeclared signal: {name}")
+ self._sigs[name] = {
+ "widget": widget,
+ "callbacks": [],
+ "thing": thing,
+ "log": log_level,
+ }
+ wn = "-".join(
+ [
+ getattr(widget, "name", str(widget)) if widget is not None else "none",
+ thing,
+ ]
+ )
+ self._map[wn] = name
+ if widget is not None:
+ widget.param.watch(self._signal, thing, onlychanged=True)
+ if auto and hasattr(self, name):
+ self.connect(name, getattr(self, name))
+
+ def _repr_mimebundle_(self, *args, **kwargs):
+ """Display in a notebook or a server"""
+ try:
+ return self.panel._repr_mimebundle_(*args, **kwargs)
+ except (ValueError, AttributeError):
+ raise NotImplementedError("Panel does not seem to be set up properly")
+
+ def connect(self, signal, slot):
+ """Associate call back with given event
+
+ The callback must be a function which takes the "new" value of the
+ watched attribute as the only parameter. If the callback return False,
+ this cancels any further processing of the given event.
+
+ Alternatively, the callback can be a string, in which case it means
+ emitting the correspondingly-named event (i.e., connect to self)
+ """
+ self._sigs[signal]["callbacks"].append(slot)
+
+ def _signal(self, event):
+ """This is called by a an action on a widget
+
+ Within an self.ignore_events context, nothing happens.
+
+ Tests can execute this method by directly changing the values of
+ widget components.
+ """
+ if not self._ignoring_events:
+ wn = "-".join([event.obj.name, event.name])
+ if wn in self._map and self._map[wn] in self._sigs:
+ self._emit(self._map[wn], event.new)
+
+ @contextlib.contextmanager
+ def ignore_events(self):
+ """Temporarily turn off events processing in this instance
+
+ (does not propagate to children)
+ """
+ self._ignoring_events = True
+ try:
+ yield
+ finally:
+ self._ignoring_events = False
+
+ def _emit(self, sig, value=None):
+ """An event happened, call its callbacks
+
+ This method can be used in tests to simulate message passing without
+ directly changing visual elements.
+
+ Calling of callbacks will halt whenever one returns False.
+ """
+ logger.log(self._sigs[sig]["log"], f"{sig}: {value}")
+ for callback in self._sigs[sig]["callbacks"]:
+ if isinstance(callback, str):
+ self._emit(callback)
+ else:
+ try:
+ # running callbacks should not break the interface
+ ret = callback(value)
+ if ret is False:
+ break
+ except Exception as e:
+ logger.exception(
+ "Exception (%s) while executing callback for signal: %s",
+ e,
+ sig,
+ )
+
+ def show(self, threads=False):
+ """Open a new browser tab and display this instance's interface"""
+ self.panel.show(threads=threads, verbose=False)
+ return self
+
+
+class SingleSelect(SigSlot):
+ """A multiselect which only allows you to select one item for an event"""
+
+ signals = ["_selected", "selected"] # the first is internal
+ slots = ["set_options", "set_selection", "add", "clear", "select"]
+
+ def __init__(self, **kwargs):
+ self.kwargs = kwargs
+ super().__init__()
+
+ def _setup(self):
+ self.panel = pn.widgets.MultiSelect(**self.kwargs)
+ self._register(self.panel, "_selected", "value")
+ self._register(None, "selected")
+ self.connect("_selected", self.select_one)
+
+ def _signal(self, *args, **kwargs):
+ super()._signal(*args, **kwargs)
+
+ def select_one(self, *_):
+ with self.ignore_events():
+ val = [self.panel.value[-1]] if self.panel.value else []
+ self.panel.value = val
+ self._emit("selected", self.panel.value)
+
+ def set_options(self, options):
+ self.panel.options = options
+
+ def clear(self):
+ self.panel.options = []
+
+ @property
+ def value(self):
+ return self.panel.value
+
+ def set_selection(self, selection):
+ self.panel.value = [selection]
+
+
+class FileSelector(SigSlot):
+ """Panel-based graphical file selector widget
+
+ Instances of this widget are interactive and can be displayed in jupyter by having
+ them as the output of a cell, or in a separate browser tab using ``.show()``.
+ """
+
+ signals = [
+ "protocol_changed",
+ "selection_changed",
+ "directory_entered",
+ "home_clicked",
+ "up_clicked",
+ "go_clicked",
+ "filters_changed",
+ ]
+ slots = ["set_filters", "go_home"]
+
+ def __init__(self, url=None, filters=None, ignore=None, kwargs=None):
+ """
+
+ Parameters
+ ----------
+ url : str (optional)
+ Initial value of the URL to populate the dialog; should include protocol
+ filters : list(str) (optional)
+ File endings to include in the listings. If not included, all files are
+ allowed. Does not affect directories.
+ If given, the endings will appear as checkboxes in the interface
+ ignore : list(str) (optional)
+ Regex(s) of file basename patterns to ignore, e.g., "\\." for typical
+ hidden files on posix
+ kwargs : dict (optional)
+ To pass to file system instance
+ """
+ if url:
+ self.init_protocol, url = split_protocol(url)
+ else:
+ self.init_protocol, url = "file", os.getcwd()
+ self.init_url = url
+ self.init_kwargs = (kwargs if isinstance(kwargs, str) else str(kwargs)) or "{}"
+ self.filters = filters
+ self.ignore = [re.compile(i) for i in ignore or []]
+ self._fs = None
+ super().__init__()
+
+ def _setup(self):
+ self.url = pn.widgets.TextInput(
+ name="url",
+ value=self.init_url,
+ align="end",
+ sizing_mode="stretch_width",
+ width_policy="max",
+ )
+ self.protocol = pn.widgets.Select(
+ options=sorted(known_implementations),
+ value=self.init_protocol,
+ name="protocol",
+ align="center",
+ )
+ self.kwargs = pn.widgets.TextInput(
+ name="kwargs", value=self.init_kwargs, align="center"
+ )
+ self.go = pn.widgets.Button(name="β¨", align="end", width=45)
+ self.main = SingleSelect(size=10)
+ self.home = pn.widgets.Button(name="π ", width=40, height=30, align="end")
+ self.up = pn.widgets.Button(name="βΉ", width=30, height=30, align="end")
+
+ self._register(self.protocol, "protocol_changed", auto=True)
+ self._register(self.go, "go_clicked", "clicks", auto=True)
+ self._register(self.up, "up_clicked", "clicks", auto=True)
+ self._register(self.home, "home_clicked", "clicks", auto=True)
+ self._register(None, "selection_changed")
+ self.main.connect("selected", self.selection_changed)
+ self._register(None, "directory_entered")
+ self.prev_protocol = self.protocol.value
+ self.prev_kwargs = self.storage_options
+
+ self.filter_sel = pn.widgets.CheckBoxGroup(
+ value=[], options=[], inline=False, align="end", width_policy="min"
+ )
+ self._register(self.filter_sel, "filters_changed", auto=True)
+
+ self.panel = pn.Column(
+ pn.Row(self.protocol, self.kwargs),
+ pn.Row(self.home, self.up, self.url, self.go, self.filter_sel),
+ self.main.panel,
+ )
+ self.set_filters(self.filters)
+ self.go_clicked()
+
+ def set_filters(self, filters=None):
+ self.filters = filters
+ if filters:
+ self.filter_sel.options = filters
+ self.filter_sel.value = filters
+ else:
+ self.filter_sel.options = []
+ self.filter_sel.value = []
+
+ @property
+ def storage_options(self):
+ """Value of the kwargs box as a dictionary"""
+ return ast.literal_eval(self.kwargs.value) or {}
+
+ @property
+ def fs(self):
+ """Current filesystem instance"""
+ if self._fs is None:
+ cls = get_filesystem_class(self.protocol.value)
+ self._fs = cls(**self.storage_options)
+ return self._fs
+
+ @property
+ def urlpath(self):
+ """URL of currently selected item"""
+ return (
+ (f"{self.protocol.value}://{self.main.value[0]}")
+ if self.main.value
+ else None
+ )
+
+ def open_file(self, mode="rb", compression=None, encoding=None):
+ """Create OpenFile instance for the currently selected item
+
+ For example, in a notebook you might do something like
+
+ .. code-block::
+
+ [ ]: sel = FileSelector(); sel
+
+ # user selects their file
+
+ [ ]: with sel.open_file('rb') as f:
+ ... out = f.read()
+
+ Parameters
+ ----------
+ mode: str (optional)
+ Open mode for the file.
+ compression: str (optional)
+ The interact with the file as compressed. Set to 'infer' to guess
+ compression from the file ending
+ encoding: str (optional)
+ If using text mode, use this encoding; defaults to UTF8.
+ """
+ if self.urlpath is None:
+ raise ValueError("No file selected")
+ return OpenFile(self.fs, self.urlpath, mode, compression, encoding)
+
+ def filters_changed(self, values):
+ self.filters = values
+ self.go_clicked()
+
+ def selection_changed(self, *_):
+ if self.urlpath is None:
+ return
+ if self.fs.isdir(self.urlpath):
+ self.url.value = self.fs._strip_protocol(self.urlpath)
+ self.go_clicked()
+
+ def go_clicked(self, *_):
+ if (
+ self.prev_protocol != self.protocol.value
+ or self.prev_kwargs != self.storage_options
+ ):
+ self._fs = None # causes fs to be recreated
+ self.prev_protocol = self.protocol.value
+ self.prev_kwargs = self.storage_options
+ listing = sorted(
+ self.fs.ls(self.url.value, detail=True), key=lambda x: x["name"]
+ )
+ listing = [
+ l
+ for l in listing
+ if not any(i.match(l["name"].rsplit("/", 1)[-1]) for i in self.ignore)
+ ]
+ folders = {
+ "π " + o["name"].rsplit("/", 1)[-1]: o["name"]
+ for o in listing
+ if o["type"] == "directory"
+ }
+ files = {
+ "π " + o["name"].rsplit("/", 1)[-1]: o["name"]
+ for o in listing
+ if o["type"] == "file"
+ }
+ if self.filters:
+ files = {
+ k: v
+ for k, v in files.items()
+ if any(v.endswith(ext) for ext in self.filters)
+ }
+ self.main.set_options(dict(**folders, **files))
+
+ def protocol_changed(self, *_):
+ self._fs = None
+ self.main.options = []
+ self.url.value = ""
+
+ def home_clicked(self, *_):
+ self.protocol.value = self.init_protocol
+ self.kwargs.value = self.init_kwargs
+ self.url.value = self.init_url
+ self.go_clicked()
+
+ def up_clicked(self, *_):
+ self.url.value = self.fs._parent(self.url.value)
+ self.go_clicked()
diff --git a/parrot/lib/python3.10/site-packages/fsspec/implementations/cache_metadata.py b/parrot/lib/python3.10/site-packages/fsspec/implementations/cache_metadata.py
new file mode 100644
index 0000000000000000000000000000000000000000..bd9b5cdd99d7f4a0a989c0f7d0c70ddcf324816a
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/fsspec/implementations/cache_metadata.py
@@ -0,0 +1,232 @@
+from __future__ import annotations
+
+import os
+import pickle
+import time
+from typing import TYPE_CHECKING
+
+from fsspec.utils import atomic_write
+
+try:
+ import ujson as json
+except ImportError:
+ if not TYPE_CHECKING:
+ import json
+
+if TYPE_CHECKING:
+ from typing import Any, Dict, Iterator, Literal
+
+ from typing_extensions import TypeAlias
+
+ from .cached import CachingFileSystem
+
+ Detail: TypeAlias = Dict[str, Any]
+
+
+class CacheMetadata:
+ """Cache metadata.
+
+ All reading and writing of cache metadata is performed by this class,
+ accessing the cached files and blocks is not.
+
+ Metadata is stored in a single file per storage directory in JSON format.
+ For backward compatibility, also reads metadata stored in pickle format
+ which is converted to JSON when next saved.
+ """
+
+ def __init__(self, storage: list[str]):
+ """
+
+ Parameters
+ ----------
+ storage: list[str]
+ Directories containing cached files, must be at least one. Metadata
+ is stored in the last of these directories by convention.
+ """
+ if not storage:
+ raise ValueError("CacheMetadata expects at least one storage location")
+
+ self._storage = storage
+ self.cached_files: list[Detail] = [{}]
+
+ # Private attribute to force saving of metadata in pickle format rather than
+ # JSON for use in tests to confirm can read both pickle and JSON formats.
+ self._force_save_pickle = False
+
+ def _load(self, fn: str) -> Detail:
+ """Low-level function to load metadata from specific file"""
+ try:
+ with open(fn, "r") as f:
+ loaded = json.load(f)
+ except ValueError:
+ with open(fn, "rb") as f:
+ loaded = pickle.load(f)
+ for c in loaded.values():
+ if isinstance(c.get("blocks"), list):
+ c["blocks"] = set(c["blocks"])
+ return loaded
+
+ def _save(self, metadata_to_save: Detail, fn: str) -> None:
+ """Low-level function to save metadata to specific file"""
+ if self._force_save_pickle:
+ with atomic_write(fn) as f:
+ pickle.dump(metadata_to_save, f)
+ else:
+ with atomic_write(fn, mode="w") as f:
+ json.dump(metadata_to_save, f)
+
+ def _scan_locations(
+ self, writable_only: bool = False
+ ) -> Iterator[tuple[str, str, bool]]:
+ """Yield locations (filenames) where metadata is stored, and whether
+ writable or not.
+
+ Parameters
+ ----------
+ writable: bool
+ Set to True to only yield writable locations.
+
+ Returns
+ -------
+ Yields (str, str, bool)
+ """
+ n = len(self._storage)
+ for i, storage in enumerate(self._storage):
+ writable = i == n - 1
+ if writable_only and not writable:
+ continue
+ yield os.path.join(storage, "cache"), storage, writable
+
+ def check_file(
+ self, path: str, cfs: CachingFileSystem | None
+ ) -> Literal[False] | tuple[Detail, str]:
+ """If path is in cache return its details, otherwise return ``False``.
+
+ If the optional CachingFileSystem is specified then it is used to
+ perform extra checks to reject possible matches, such as if they are
+ too old.
+ """
+ for (fn, base, _), cache in zip(self._scan_locations(), self.cached_files):
+ if path not in cache:
+ continue
+ detail = cache[path].copy()
+
+ if cfs is not None:
+ if cfs.check_files and detail["uid"] != cfs.fs.ukey(path):
+ # Wrong file as determined by hash of file properties
+ continue
+ if cfs.expiry and time.time() - detail["time"] > cfs.expiry:
+ # Cached file has expired
+ continue
+
+ fn = os.path.join(base, detail["fn"])
+ if os.path.exists(fn):
+ return detail, fn
+ return False
+
+ def clear_expired(self, expiry_time: int) -> tuple[list[str], bool]:
+ """Remove expired metadata from the cache.
+
+ Returns names of files corresponding to expired metadata and a boolean
+ flag indicating whether the writable cache is empty. Caller is
+ responsible for deleting the expired files.
+ """
+ expired_files = []
+ for path, detail in self.cached_files[-1].copy().items():
+ if time.time() - detail["time"] > expiry_time:
+ fn = detail.get("fn", "")
+ if not fn:
+ raise RuntimeError(
+ f"Cache metadata does not contain 'fn' for {path}"
+ )
+ fn = os.path.join(self._storage[-1], fn)
+ expired_files.append(fn)
+ self.cached_files[-1].pop(path)
+
+ if self.cached_files[-1]:
+ cache_path = os.path.join(self._storage[-1], "cache")
+ self._save(self.cached_files[-1], cache_path)
+
+ writable_cache_empty = not self.cached_files[-1]
+ return expired_files, writable_cache_empty
+
+ def load(self) -> None:
+ """Load all metadata from disk and store in ``self.cached_files``"""
+ cached_files = []
+ for fn, _, _ in self._scan_locations():
+ if os.path.exists(fn):
+ # TODO: consolidate blocks here
+ cached_files.append(self._load(fn))
+ else:
+ cached_files.append({})
+ self.cached_files = cached_files or [{}]
+
+ def on_close_cached_file(self, f: Any, path: str) -> None:
+ """Perform side-effect actions on closing a cached file.
+
+ The actual closing of the file is the responsibility of the caller.
+ """
+ # File must be writeble, so in self.cached_files[-1]
+ c = self.cached_files[-1][path]
+ if c["blocks"] is not True and len(c["blocks"]) * f.blocksize >= f.size:
+ c["blocks"] = True
+
+ def pop_file(self, path: str) -> str | None:
+ """Remove metadata of cached file.
+
+ If path is in the cache, return the filename of the cached file,
+ otherwise return ``None``. Caller is responsible for deleting the
+ cached file.
+ """
+ details = self.check_file(path, None)
+ if not details:
+ return None
+ _, fn = details
+ if fn.startswith(self._storage[-1]):
+ self.cached_files[-1].pop(path)
+ self.save()
+ else:
+ raise PermissionError(
+ "Can only delete cached file in last, writable cache location"
+ )
+ return fn
+
+ def save(self) -> None:
+ """Save metadata to disk"""
+ for (fn, _, writable), cache in zip(self._scan_locations(), self.cached_files):
+ if not writable:
+ continue
+
+ if os.path.exists(fn):
+ cached_files = self._load(fn)
+ for k, c in cached_files.items():
+ if k in cache:
+ if c["blocks"] is True or cache[k]["blocks"] is True:
+ c["blocks"] = True
+ else:
+ # self.cached_files[*][*]["blocks"] must continue to
+ # point to the same set object so that updates
+ # performed by MMapCache are propagated back to
+ # self.cached_files.
+ blocks = cache[k]["blocks"]
+ blocks.update(c["blocks"])
+ c["blocks"] = blocks
+ c["time"] = max(c["time"], cache[k]["time"])
+ c["uid"] = cache[k]["uid"]
+
+ # Files can be added to cache after it was written once
+ for k, c in cache.items():
+ if k not in cached_files:
+ cached_files[k] = c
+ else:
+ cached_files = cache
+ cache = {k: v.copy() for k, v in cached_files.items()}
+ for c in cache.values():
+ if isinstance(c["blocks"], set):
+ c["blocks"] = list(c["blocks"])
+ self._save(cache, fn)
+ self.cached_files[-1] = cached_files
+
+ def update_file(self, path: str, detail: Detail) -> None:
+ """Update metadata for specific file in memory, do not save"""
+ self.cached_files[-1][path] = detail
diff --git a/parrot/lib/python3.10/site-packages/fsspec/implementations/dask.py b/parrot/lib/python3.10/site-packages/fsspec/implementations/dask.py
new file mode 100644
index 0000000000000000000000000000000000000000..3e1276463db6866665e6a0fe114efc247971b57e
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/fsspec/implementations/dask.py
@@ -0,0 +1,152 @@
+import dask
+from distributed.client import Client, _get_global_client
+from distributed.worker import Worker
+
+from fsspec import filesystem
+from fsspec.spec import AbstractBufferedFile, AbstractFileSystem
+from fsspec.utils import infer_storage_options
+
+
+def _get_client(client):
+ if client is None:
+ return _get_global_client()
+ elif isinstance(client, Client):
+ return client
+ else:
+ # e.g., connection string
+ return Client(client)
+
+
+def _in_worker():
+ return bool(Worker._instances)
+
+
+class DaskWorkerFileSystem(AbstractFileSystem):
+ """View files accessible to a worker as any other remote file-system
+
+ When instances are run on the worker, uses the real filesystem. When
+ run on the client, they call the worker to provide information or data.
+
+ **Warning** this implementation is experimental, and read-only for now.
+ """
+
+ def __init__(
+ self, target_protocol=None, target_options=None, fs=None, client=None, **kwargs
+ ):
+ super().__init__(**kwargs)
+ if not (fs is None) ^ (target_protocol is None):
+ raise ValueError(
+ "Please provide one of filesystem instance (fs) or"
+ " target_protocol, not both"
+ )
+ self.target_protocol = target_protocol
+ self.target_options = target_options
+ self.worker = None
+ self.client = client
+ self.fs = fs
+ self._determine_worker()
+
+ @staticmethod
+ def _get_kwargs_from_urls(path):
+ so = infer_storage_options(path)
+ if "host" in so and "port" in so:
+ return {"client": f"{so['host']}:{so['port']}"}
+ else:
+ return {}
+
+ def _determine_worker(self):
+ if _in_worker():
+ self.worker = True
+ if self.fs is None:
+ self.fs = filesystem(
+ self.target_protocol, **(self.target_options or {})
+ )
+ else:
+ self.worker = False
+ self.client = _get_client(self.client)
+ self.rfs = dask.delayed(self)
+
+ def mkdir(self, *args, **kwargs):
+ if self.worker:
+ self.fs.mkdir(*args, **kwargs)
+ else:
+ self.rfs.mkdir(*args, **kwargs).compute()
+
+ def rm(self, *args, **kwargs):
+ if self.worker:
+ self.fs.rm(*args, **kwargs)
+ else:
+ self.rfs.rm(*args, **kwargs).compute()
+
+ def copy(self, *args, **kwargs):
+ if self.worker:
+ self.fs.copy(*args, **kwargs)
+ else:
+ self.rfs.copy(*args, **kwargs).compute()
+
+ def mv(self, *args, **kwargs):
+ if self.worker:
+ self.fs.mv(*args, **kwargs)
+ else:
+ self.rfs.mv(*args, **kwargs).compute()
+
+ def ls(self, *args, **kwargs):
+ if self.worker:
+ return self.fs.ls(*args, **kwargs)
+ else:
+ return self.rfs.ls(*args, **kwargs).compute()
+
+ def _open(
+ self,
+ path,
+ mode="rb",
+ block_size=None,
+ autocommit=True,
+ cache_options=None,
+ **kwargs,
+ ):
+ if self.worker:
+ return self.fs._open(
+ path,
+ mode=mode,
+ block_size=block_size,
+ autocommit=autocommit,
+ cache_options=cache_options,
+ **kwargs,
+ )
+ else:
+ return DaskFile(
+ fs=self,
+ path=path,
+ mode=mode,
+ block_size=block_size,
+ autocommit=autocommit,
+ cache_options=cache_options,
+ **kwargs,
+ )
+
+ def fetch_range(self, path, mode, start, end):
+ if self.worker:
+ with self._open(path, mode) as f:
+ f.seek(start)
+ return f.read(end - start)
+ else:
+ return self.rfs.fetch_range(path, mode, start, end).compute()
+
+
+class DaskFile(AbstractBufferedFile):
+ def __init__(self, mode="rb", **kwargs):
+ if mode != "rb":
+ raise ValueError('Remote dask files can only be opened in "rb" mode')
+ super().__init__(**kwargs)
+
+ def _upload_chunk(self, final=False):
+ pass
+
+ def _initiate_upload(self):
+ """Create remote file/upload"""
+ pass
+
+ def _fetch_range(self, start, end):
+ """Get the specified set of bytes from remote"""
+ return self.fs.fetch_range(self.path, self.mode, start, end)
diff --git a/parrot/lib/python3.10/site-packages/fsspec/implementations/jupyter.py b/parrot/lib/python3.10/site-packages/fsspec/implementations/jupyter.py
new file mode 100644
index 0000000000000000000000000000000000000000..2839f4c1feea56dddd54bdc00f0b884c8461d29e
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/fsspec/implementations/jupyter.py
@@ -0,0 +1,124 @@
+import base64
+import io
+import re
+
+import requests
+
+import fsspec
+
+
+class JupyterFileSystem(fsspec.AbstractFileSystem):
+ """View of the files as seen by a Jupyter server (notebook or lab)"""
+
+ protocol = ("jupyter", "jlab")
+
+ def __init__(self, url, tok=None, **kwargs):
+ """
+
+ Parameters
+ ----------
+ url : str
+ Base URL of the server, like "http://127.0.0.1:8888". May include
+ token in the string, which is given by the process when starting up
+ tok : str
+ If the token is obtained separately, can be given here
+ kwargs
+ """
+ if "?" in url:
+ if tok is None:
+ try:
+ tok = re.findall("token=([a-z0-9]+)", url)[0]
+ except IndexError as e:
+ raise ValueError("Could not determine token") from e
+ url = url.split("?", 1)[0]
+ self.url = url.rstrip("/") + "/api/contents"
+ self.session = requests.Session()
+ if tok:
+ self.session.headers["Authorization"] = f"token {tok}"
+
+ super().__init__(**kwargs)
+
+ def ls(self, path, detail=True, **kwargs):
+ path = self._strip_protocol(path)
+ r = self.session.get(f"{self.url}/{path}")
+ if r.status_code == 404:
+ return FileNotFoundError(path)
+ r.raise_for_status()
+ out = r.json()
+
+ if out["type"] == "directory":
+ out = out["content"]
+ else:
+ out = [out]
+ for o in out:
+ o["name"] = o.pop("path")
+ o.pop("content")
+ if o["type"] == "notebook":
+ o["type"] = "file"
+ if detail:
+ return out
+ return [o["name"] for o in out]
+
+ def cat_file(self, path, start=None, end=None, **kwargs):
+ path = self._strip_protocol(path)
+ r = self.session.get(f"{self.url}/{path}")
+ if r.status_code == 404:
+ return FileNotFoundError(path)
+ r.raise_for_status()
+ out = r.json()
+ if out["format"] == "text":
+ # data should be binary
+ b = out["content"].encode()
+ else:
+ b = base64.b64decode(out["content"])
+ return b[start:end]
+
+ def pipe_file(self, path, value, **_):
+ path = self._strip_protocol(path)
+ json = {
+ "name": path.rsplit("/", 1)[-1],
+ "path": path,
+ "size": len(value),
+ "content": base64.b64encode(value).decode(),
+ "format": "base64",
+ "type": "file",
+ }
+ self.session.put(f"{self.url}/{path}", json=json)
+
+ def mkdir(self, path, create_parents=True, **kwargs):
+ path = self._strip_protocol(path)
+ if create_parents and "/" in path:
+ self.mkdir(path.rsplit("/", 1)[0], True)
+ json = {
+ "name": path.rsplit("/", 1)[-1],
+ "path": path,
+ "size": None,
+ "content": None,
+ "type": "directory",
+ }
+ self.session.put(f"{self.url}/{path}", json=json)
+
+ def _rm(self, path):
+ path = self._strip_protocol(path)
+ self.session.delete(f"{self.url}/{path}")
+
+ def _open(self, path, mode="rb", **kwargs):
+ path = self._strip_protocol(path)
+ if mode == "rb":
+ data = self.cat_file(path)
+ return io.BytesIO(data)
+ else:
+ return SimpleFileWriter(self, path, mode="wb")
+
+
+class SimpleFileWriter(fsspec.spec.AbstractBufferedFile):
+ def _upload_chunk(self, final=False):
+ """Never uploads a chunk until file is done
+
+ Not suitable for large files
+ """
+ if final is False:
+ return False
+ self.buffer.seek(0)
+ data = self.buffer.read()
+ self.fs.pipe_file(self.path, data)
diff --git a/parrot/lib/python3.10/site-packages/fsspec/implementations/memory.py b/parrot/lib/python3.10/site-packages/fsspec/implementations/memory.py
new file mode 100644
index 0000000000000000000000000000000000000000..83e7e74d6ceceaf6e75268923094bfdf56b72fc7
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/fsspec/implementations/memory.py
@@ -0,0 +1,303 @@
+from __future__ import annotations
+
+import logging
+from datetime import datetime, timezone
+from errno import ENOTEMPTY
+from io import BytesIO
+from pathlib import PurePath, PureWindowsPath
+from typing import Any, ClassVar
+
+from fsspec import AbstractFileSystem
+from fsspec.implementations.local import LocalFileSystem
+from fsspec.utils import stringify_path
+
+logger = logging.getLogger("fsspec.memoryfs")
+
+
+class MemoryFileSystem(AbstractFileSystem):
+ """A filesystem based on a dict of BytesIO objects
+
+ This is a global filesystem so instances of this class all point to the same
+ in memory filesystem.
+ """
+
+ store: ClassVar[dict[str, Any]] = {} # global, do not overwrite!
+ pseudo_dirs = [""] # global, do not overwrite!
+ protocol = "memory"
+ root_marker = "/"
+
+ @classmethod
+ def _strip_protocol(cls, path):
+ if isinstance(path, PurePath):
+ if isinstance(path, PureWindowsPath):
+ return LocalFileSystem._strip_protocol(path)
+ else:
+ path = stringify_path(path)
+
+ if path.startswith("memory://"):
+ path = path[len("memory://") :]
+ if "::" in path or "://" in path:
+ return path.rstrip("/")
+ path = path.lstrip("/").rstrip("/")
+ return "/" + path if path else ""
+
+ def ls(self, path, detail=True, **kwargs):
+ path = self._strip_protocol(path)
+ if path in self.store:
+ # there is a key with this exact name
+ if not detail:
+ return [path]
+ return [
+ {
+ "name": path,
+ "size": self.store[path].size,
+ "type": "file",
+ "created": self.store[path].created.timestamp(),
+ }
+ ]
+ paths = set()
+ starter = path + "/"
+ out = []
+ for p2 in tuple(self.store):
+ if p2.startswith(starter):
+ if "/" not in p2[len(starter) :]:
+ # exact child
+ out.append(
+ {
+ "name": p2,
+ "size": self.store[p2].size,
+ "type": "file",
+ "created": self.store[p2].created.timestamp(),
+ }
+ )
+ elif len(p2) > len(starter):
+ # implied child directory
+ ppath = starter + p2[len(starter) :].split("/", 1)[0]
+ if ppath not in paths:
+ out = out or []
+ out.append(
+ {
+ "name": ppath,
+ "size": 0,
+ "type": "directory",
+ }
+ )
+ paths.add(ppath)
+ for p2 in self.pseudo_dirs:
+ if p2.startswith(starter):
+ if "/" not in p2[len(starter) :]:
+ # exact child pdir
+ if p2 not in paths:
+ out.append({"name": p2, "size": 0, "type": "directory"})
+ paths.add(p2)
+ else:
+ # directory implied by deeper pdir
+ ppath = starter + p2[len(starter) :].split("/", 1)[0]
+ if ppath not in paths:
+ out.append({"name": ppath, "size": 0, "type": "directory"})
+ paths.add(ppath)
+ if not out:
+ if path in self.pseudo_dirs:
+ # empty dir
+ return []
+ raise FileNotFoundError(path)
+ if detail:
+ return out
+ return sorted([f["name"] for f in out])
+
+ def mkdir(self, path, create_parents=True, **kwargs):
+ path = self._strip_protocol(path)
+ if path in self.store or path in self.pseudo_dirs:
+ raise FileExistsError(path)
+ if self._parent(path).strip("/") and self.isfile(self._parent(path)):
+ raise NotADirectoryError(self._parent(path))
+ if create_parents and self._parent(path).strip("/"):
+ try:
+ self.mkdir(self._parent(path), create_parents, **kwargs)
+ except FileExistsError:
+ pass
+ if path and path not in self.pseudo_dirs:
+ self.pseudo_dirs.append(path)
+
+ def makedirs(self, path, exist_ok=False):
+ try:
+ self.mkdir(path, create_parents=True)
+ except FileExistsError:
+ if not exist_ok:
+ raise
+
+ def pipe_file(self, path, value, **kwargs):
+ """Set the bytes of given file
+
+ Avoids copies of the data if possible
+ """
+ self.open(path, "wb", data=value)
+
+ def rmdir(self, path):
+ path = self._strip_protocol(path)
+ if path == "":
+ # silently avoid deleting FS root
+ return
+ if path in self.pseudo_dirs:
+ if not self.ls(path):
+ self.pseudo_dirs.remove(path)
+ else:
+ raise OSError(ENOTEMPTY, "Directory not empty", path)
+ else:
+ raise FileNotFoundError(path)
+
+ def info(self, path, **kwargs):
+ logger.debug("info: %s", path)
+ path = self._strip_protocol(path)
+ if path in self.pseudo_dirs or any(
+ p.startswith(path + "/") for p in list(self.store) + self.pseudo_dirs
+ ):
+ return {
+ "name": path,
+ "size": 0,
+ "type": "directory",
+ }
+ elif path in self.store:
+ filelike = self.store[path]
+ return {
+ "name": path,
+ "size": filelike.size,
+ "type": "file",
+ "created": getattr(filelike, "created", None),
+ }
+ else:
+ raise FileNotFoundError(path)
+
+ def _open(
+ self,
+ path,
+ mode="rb",
+ block_size=None,
+ autocommit=True,
+ cache_options=None,
+ **kwargs,
+ ):
+ path = self._strip_protocol(path)
+ if path in self.pseudo_dirs:
+ raise IsADirectoryError(path)
+ parent = path
+ while len(parent) > 1:
+ parent = self._parent(parent)
+ if self.isfile(parent):
+ raise FileExistsError(parent)
+ if mode in ["rb", "ab", "r+b"]:
+ if path in self.store:
+ f = self.store[path]
+ if mode == "ab":
+ # position at the end of file
+ f.seek(0, 2)
+ else:
+ # position at the beginning of file
+ f.seek(0)
+ return f
+ else:
+ raise FileNotFoundError(path)
+ elif mode == "wb":
+ m = MemoryFile(self, path, kwargs.get("data"))
+ if not self._intrans:
+ m.commit()
+ return m
+ else:
+ name = self.__class__.__name__
+ raise ValueError(f"unsupported file mode for {name}: {mode!r}")
+
+ def cp_file(self, path1, path2, **kwargs):
+ path1 = self._strip_protocol(path1)
+ path2 = self._strip_protocol(path2)
+ if self.isfile(path1):
+ self.store[path2] = MemoryFile(
+ self, path2, self.store[path1].getvalue()
+ ) # implicit copy
+ elif self.isdir(path1):
+ if path2 not in self.pseudo_dirs:
+ self.pseudo_dirs.append(path2)
+ else:
+ raise FileNotFoundError(path1)
+
+ def cat_file(self, path, start=None, end=None, **kwargs):
+ logger.debug("cat: %s", path)
+ path = self._strip_protocol(path)
+ try:
+ return bytes(self.store[path].getbuffer()[start:end])
+ except KeyError:
+ raise FileNotFoundError(path)
+
+ def _rm(self, path):
+ path = self._strip_protocol(path)
+ try:
+ del self.store[path]
+ except KeyError as e:
+ raise FileNotFoundError(path) from e
+
+ def modified(self, path):
+ path = self._strip_protocol(path)
+ try:
+ return self.store[path].modified
+ except KeyError:
+ raise FileNotFoundError(path)
+
+ def created(self, path):
+ path = self._strip_protocol(path)
+ try:
+ return self.store[path].created
+ except KeyError:
+ raise FileNotFoundError(path)
+
+ def rm(self, path, recursive=False, maxdepth=None):
+ if isinstance(path, str):
+ path = self._strip_protocol(path)
+ else:
+ path = [self._strip_protocol(p) for p in path]
+ paths = self.expand_path(path, recursive=recursive, maxdepth=maxdepth)
+ for p in reversed(paths):
+ # If the expanded path doesn't exist, it is only because the expanded
+ # path was a directory that does not exist in self.pseudo_dirs. This
+ # is possible if you directly create files without making the
+ # directories first.
+ if not self.exists(p):
+ continue
+ if self.isfile(p):
+ self.rm_file(p)
+ else:
+ self.rmdir(p)
+
+
+class MemoryFile(BytesIO):
+ """A BytesIO which can't close and works as a context manager
+
+ Can initialise with data. Each path should only be active once at any moment.
+
+ No need to provide fs, path if auto-committing (default)
+ """
+
+ def __init__(self, fs=None, path=None, data=None):
+ logger.debug("open file %s", path)
+ self.fs = fs
+ self.path = path
+ self.created = datetime.now(tz=timezone.utc)
+ self.modified = datetime.now(tz=timezone.utc)
+ if data:
+ super().__init__(data)
+ self.seek(0)
+
+ @property
+ def size(self):
+ return self.getbuffer().nbytes
+
+ def __enter__(self):
+ return self
+
+ def close(self):
+ pass
+
+ def discard(self):
+ pass
+
+ def commit(self):
+ self.fs.store[self.path] = self
+ self.modified = datetime.now(tz=timezone.utc)
diff --git a/parrot/lib/python3.10/site-packages/fsspec/implementations/smb.py b/parrot/lib/python3.10/site-packages/fsspec/implementations/smb.py
new file mode 100644
index 0000000000000000000000000000000000000000..bcd13a638a4d3756f4a76c315b95804397eac48f
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/fsspec/implementations/smb.py
@@ -0,0 +1,343 @@
+"""
+This module contains SMBFileSystem class responsible for handling access to
+Windows Samba network shares by using package smbprotocol
+"""
+
+import datetime
+import uuid
+from stat import S_ISDIR, S_ISLNK
+
+import smbclient
+
+from .. import AbstractFileSystem
+from ..utils import infer_storage_options
+
+# ! pylint: disable=bad-continuation
+
+
+class SMBFileSystem(AbstractFileSystem):
+ """Allow reading and writing to Windows and Samba network shares.
+
+ When using `fsspec.open()` for getting a file-like object the URI
+ should be specified as this format:
+ ``smb://workgroup;user:password@server:port/share/folder/file.csv``.
+
+ Example::
+
+ >>> import fsspec
+ >>> with fsspec.open(
+ ... 'smb://myuser:mypassword@myserver.com/' 'share/folder/file.csv'
+ ... ) as smbfile:
+ ... df = pd.read_csv(smbfile, sep='|', header=None)
+
+ Note that you need to pass in a valid hostname or IP address for the host
+ component of the URL. Do not use the Windows/NetBIOS machine name for the
+ host component.
+
+ The first component of the path in the URL points to the name of the shared
+ folder. Subsequent path components will point to the directory/folder/file.
+
+ The URL components ``workgroup`` , ``user``, ``password`` and ``port`` may be
+ optional.
+
+ .. note::
+
+ For working this source require `smbprotocol`_ to be installed, e.g.::
+
+ $ pip install smbprotocol
+ # or
+ # pip install smbprotocol[kerberos]
+
+ .. _smbprotocol: https://github.com/jborean93/smbprotocol#requirements
+
+ Note: if using this with the ``open`` or ``open_files``, with full URLs,
+ there is no way to tell if a path is relative, so all paths are assumed
+ to be absolute.
+ """
+
+ protocol = "smb"
+
+ # pylint: disable=too-many-arguments
+ def __init__(
+ self,
+ host,
+ port=None,
+ username=None,
+ password=None,
+ timeout=60,
+ encrypt=None,
+ share_access=None,
+ register_session_retries=5,
+ auto_mkdir=False,
+ **kwargs,
+ ):
+ """
+ You can use _get_kwargs_from_urls to get some kwargs from
+ a reasonable SMB url.
+
+ Authentication will be anonymous or integrated if username/password are not
+ given.
+
+ Parameters
+ ----------
+ host: str
+ The remote server name/ip to connect to
+ port: int or None
+ Port to connect with. Usually 445, sometimes 139.
+ username: str or None
+ Username to connect with. Required if Kerberos auth is not being used.
+ password: str or None
+ User's password on the server, if using username
+ timeout: int
+ Connection timeout in seconds
+ encrypt: bool
+ Whether to force encryption or not, once this has been set to True
+ the session cannot be changed back to False.
+ share_access: str or None
+ Specifies the default access applied to file open operations
+ performed with this file system object.
+ This affects whether other processes can concurrently open a handle
+ to the same file.
+
+ - None (the default): exclusively locks the file until closed.
+ - 'r': Allow other handles to be opened with read access.
+ - 'w': Allow other handles to be opened with write access.
+ - 'd': Allow other handles to be opened with delete access.
+ auto_mkdir: bool
+ Whether, when opening a file, the directory containing it should
+ be created (if it doesn't already exist). This is assumed by pyarrow
+ and zarr-python code.
+ """
+ super().__init__(**kwargs)
+ self.host = host
+ self.port = port
+ self.username = username
+ self.password = password
+ self.timeout = timeout
+ self.encrypt = encrypt
+ self.temppath = kwargs.pop("temppath", "")
+ self.share_access = share_access
+ self.register_session_retries = register_session_retries
+ self.auto_mkdir = auto_mkdir
+ self._connect()
+
+ @property
+ def _port(self):
+ return 445 if self.port is None else self.port
+
+ def _connect(self):
+ import time
+
+ for _ in range(self.register_session_retries):
+ try:
+ smbclient.register_session(
+ self.host,
+ username=self.username,
+ password=self.password,
+ port=self._port,
+ encrypt=self.encrypt,
+ connection_timeout=self.timeout,
+ )
+ break
+ except Exception:
+ time.sleep(0.1)
+
+ @classmethod
+ def _strip_protocol(cls, path):
+ return infer_storage_options(path)["path"]
+
+ @staticmethod
+ def _get_kwargs_from_urls(path):
+ # smb://workgroup;user:password@host:port/share/folder/file.csv
+ out = infer_storage_options(path)
+ out.pop("path", None)
+ out.pop("protocol", None)
+ return out
+
+ def mkdir(self, path, create_parents=True, **kwargs):
+ wpath = _as_unc_path(self.host, path)
+ if create_parents:
+ smbclient.makedirs(wpath, exist_ok=False, port=self._port, **kwargs)
+ else:
+ smbclient.mkdir(wpath, port=self._port, **kwargs)
+
+ def makedirs(self, path, exist_ok=False):
+ if _share_has_path(path):
+ wpath = _as_unc_path(self.host, path)
+ smbclient.makedirs(wpath, exist_ok=exist_ok, port=self._port)
+
+ def rmdir(self, path):
+ if _share_has_path(path):
+ wpath = _as_unc_path(self.host, path)
+ smbclient.rmdir(wpath, port=self._port)
+
+ def info(self, path, **kwargs):
+ wpath = _as_unc_path(self.host, path)
+ stats = smbclient.stat(wpath, port=self._port, **kwargs)
+ if S_ISDIR(stats.st_mode):
+ stype = "directory"
+ elif S_ISLNK(stats.st_mode):
+ stype = "link"
+ else:
+ stype = "file"
+ res = {
+ "name": path + "/" if stype == "directory" else path,
+ "size": stats.st_size,
+ "type": stype,
+ "uid": stats.st_uid,
+ "gid": stats.st_gid,
+ "time": stats.st_atime,
+ "mtime": stats.st_mtime,
+ }
+ return res
+
+ def created(self, path):
+ """Return the created timestamp of a file as a datetime.datetime"""
+ wpath = _as_unc_path(self.host, path)
+ stats = smbclient.stat(wpath, port=self._port)
+ return datetime.datetime.fromtimestamp(stats.st_ctime, tz=datetime.timezone.utc)
+
+ def modified(self, path):
+ """Return the modified timestamp of a file as a datetime.datetime"""
+ wpath = _as_unc_path(self.host, path)
+ stats = smbclient.stat(wpath, port=self._port)
+ return datetime.datetime.fromtimestamp(stats.st_mtime, tz=datetime.timezone.utc)
+
+ def ls(self, path, detail=True, **kwargs):
+ unc = _as_unc_path(self.host, path)
+ listed = smbclient.listdir(unc, port=self._port, **kwargs)
+ dirs = ["/".join([path.rstrip("/"), p]) for p in listed]
+ if detail:
+ dirs = [self.info(d) for d in dirs]
+ return dirs
+
+ # pylint: disable=too-many-arguments
+ def _open(
+ self,
+ path,
+ mode="rb",
+ block_size=-1,
+ autocommit=True,
+ cache_options=None,
+ **kwargs,
+ ):
+ """
+ block_size: int or None
+ If 0, no buffering, 1, line buffering, >1, buffer that many bytes
+
+ Notes
+ -----
+ By specifying 'share_access' in 'kwargs' it is possible to override the
+ default shared access setting applied in the constructor of this object.
+ """
+ if self.auto_mkdir and "w" in mode:
+ self.makedirs(self._parent(path), exist_ok=True)
+ bls = block_size if block_size is not None and block_size >= 0 else -1
+ wpath = _as_unc_path(self.host, path)
+ share_access = kwargs.pop("share_access", self.share_access)
+ if "w" in mode and autocommit is False:
+ temp = _as_temp_path(self.host, path, self.temppath)
+ return SMBFileOpener(
+ wpath, temp, mode, port=self._port, block_size=bls, **kwargs
+ )
+ return smbclient.open_file(
+ wpath,
+ mode,
+ buffering=bls,
+ share_access=share_access,
+ port=self._port,
+ **kwargs,
+ )
+
+ def copy(self, path1, path2, **kwargs):
+ """Copy within two locations in the same filesystem"""
+ wpath1 = _as_unc_path(self.host, path1)
+ wpath2 = _as_unc_path(self.host, path2)
+ if self.auto_mkdir:
+ self.makedirs(self._parent(path2), exist_ok=True)
+ smbclient.copyfile(wpath1, wpath2, port=self._port, **kwargs)
+
+ def _rm(self, path):
+ if _share_has_path(path):
+ wpath = _as_unc_path(self.host, path)
+ stats = smbclient.stat(wpath, port=self._port)
+ if S_ISDIR(stats.st_mode):
+ smbclient.rmdir(wpath, port=self._port)
+ else:
+ smbclient.remove(wpath, port=self._port)
+
+ def mv(self, path1, path2, recursive=None, maxdepth=None, **kwargs):
+ wpath1 = _as_unc_path(self.host, path1)
+ wpath2 = _as_unc_path(self.host, path2)
+ smbclient.rename(wpath1, wpath2, port=self._port, **kwargs)
+
+
+def _as_unc_path(host, path):
+ rpath = path.replace("/", "\\")
+ unc = f"\\\\{host}{rpath}"
+ return unc
+
+
+def _as_temp_path(host, path, temppath):
+ share = path.split("/")[1]
+ temp_file = f"/{share}{temppath}/{uuid.uuid4()}"
+ unc = _as_unc_path(host, temp_file)
+ return unc
+
+
+def _share_has_path(path):
+ parts = path.count("/")
+ if path.endswith("/"):
+ return parts > 2
+ return parts > 1
+
+
+class SMBFileOpener:
+ """writes to remote temporary file, move on commit"""
+
+ def __init__(self, path, temp, mode, port=445, block_size=-1, **kwargs):
+ self.path = path
+ self.temp = temp
+ self.mode = mode
+ self.block_size = block_size
+ self.kwargs = kwargs
+ self.smbfile = None
+ self._incontext = False
+ self.port = port
+ self._open()
+
+ def _open(self):
+ if self.smbfile is None or self.smbfile.closed:
+ self.smbfile = smbclient.open_file(
+ self.temp,
+ self.mode,
+ port=self.port,
+ buffering=self.block_size,
+ **self.kwargs,
+ )
+
+ def commit(self):
+ """Move temp file to definitive on success."""
+ # TODO: use transaction support in SMB protocol
+ smbclient.replace(self.temp, self.path, port=self.port)
+
+ def discard(self):
+ """Remove the temp file on failure."""
+ smbclient.remove(self.temp, port=self.port)
+
+ def __fspath__(self):
+ return self.path
+
+ def __iter__(self):
+ return self.smbfile.__iter__()
+
+ def __getattr__(self, item):
+ return getattr(self.smbfile, item)
+
+ def __enter__(self):
+ self._incontext = True
+ return self.smbfile.__enter__()
+
+ def __exit__(self, exc_type, exc_value, traceback):
+ self._incontext = False
+ self.smbfile.__exit__(exc_type, exc_value, traceback)
diff --git a/parrot/lib/python3.10/site-packages/fsspec/mapping.py b/parrot/lib/python3.10/site-packages/fsspec/mapping.py
new file mode 100644
index 0000000000000000000000000000000000000000..93ebd1df3a127ab1ad7d0d218cdb4fe0217f44bd
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/fsspec/mapping.py
@@ -0,0 +1,251 @@
+import array
+import logging
+import posixpath
+import warnings
+from collections.abc import MutableMapping
+from functools import cached_property
+
+from fsspec.core import url_to_fs
+
+logger = logging.getLogger("fsspec.mapping")
+
+
+class FSMap(MutableMapping):
+ """Wrap a FileSystem instance as a mutable wrapping.
+
+ The keys of the mapping become files under the given root, and the
+ values (which must be bytes) the contents of those files.
+
+ Parameters
+ ----------
+ root: string
+ prefix for all the files
+ fs: FileSystem instance
+ check: bool (=True)
+ performs a touch at the location, to check for write access.
+
+ Examples
+ --------
+ >>> fs = FileSystem(**parameters) # doctest: +SKIP
+ >>> d = FSMap('my-data/path/', fs) # doctest: +SKIP
+ or, more likely
+ >>> d = fs.get_mapper('my-data/path/')
+
+ >>> d['loc1'] = b'Hello World' # doctest: +SKIP
+ >>> list(d.keys()) # doctest: +SKIP
+ ['loc1']
+ >>> d['loc1'] # doctest: +SKIP
+ b'Hello World'
+ """
+
+ def __init__(self, root, fs, check=False, create=False, missing_exceptions=None):
+ self.fs = fs
+ self.root = fs._strip_protocol(root)
+ self._root_key_to_str = fs._strip_protocol(posixpath.join(root, "x"))[:-1]
+ if missing_exceptions is None:
+ missing_exceptions = (
+ FileNotFoundError,
+ IsADirectoryError,
+ NotADirectoryError,
+ )
+ self.missing_exceptions = missing_exceptions
+ self.check = check
+ self.create = create
+ if create:
+ if not self.fs.exists(root):
+ self.fs.mkdir(root)
+ if check:
+ if not self.fs.exists(root):
+ raise ValueError(
+ f"Path {root} does not exist. Create "
+ f" with the ``create=True`` keyword"
+ )
+ self.fs.touch(root + "/a")
+ self.fs.rm(root + "/a")
+
+ @cached_property
+ def dirfs(self):
+ """dirfs instance that can be used with the same keys as the mapper"""
+ from .implementations.dirfs import DirFileSystem
+
+ return DirFileSystem(path=self._root_key_to_str, fs=self.fs)
+
+ def clear(self):
+ """Remove all keys below root - empties out mapping"""
+ logger.info("Clear mapping at %s", self.root)
+ try:
+ self.fs.rm(self.root, True)
+ self.fs.mkdir(self.root)
+ except: # noqa: E722
+ pass
+
+ def getitems(self, keys, on_error="raise"):
+ """Fetch multiple items from the store
+
+ If the backend is async-able, this might proceed concurrently
+
+ Parameters
+ ----------
+ keys: list(str)
+ They keys to be fetched
+ on_error : "raise", "omit", "return"
+ If raise, an underlying exception will be raised (converted to KeyError
+ if the type is in self.missing_exceptions); if omit, keys with exception
+ will simply not be included in the output; if "return", all keys are
+ included in the output, but the value will be bytes or an exception
+ instance.
+
+ Returns
+ -------
+ dict(key, bytes|exception)
+ """
+ keys2 = [self._key_to_str(k) for k in keys]
+ oe = on_error if on_error == "raise" else "return"
+ try:
+ out = self.fs.cat(keys2, on_error=oe)
+ if isinstance(out, bytes):
+ out = {keys2[0]: out}
+ except self.missing_exceptions as e:
+ raise KeyError from e
+ out = {
+ k: (KeyError() if isinstance(v, self.missing_exceptions) else v)
+ for k, v in out.items()
+ }
+ return {
+ key: out[k2]
+ for key, k2 in zip(keys, keys2)
+ if on_error == "return" or not isinstance(out[k2], BaseException)
+ }
+
+ def setitems(self, values_dict):
+ """Set the values of multiple items in the store
+
+ Parameters
+ ----------
+ values_dict: dict(str, bytes)
+ """
+ values = {self._key_to_str(k): maybe_convert(v) for k, v in values_dict.items()}
+ self.fs.pipe(values)
+
+ def delitems(self, keys):
+ """Remove multiple keys from the store"""
+ self.fs.rm([self._key_to_str(k) for k in keys])
+
+ def _key_to_str(self, key):
+ """Generate full path for the key"""
+ if not isinstance(key, str):
+ # raise TypeError("key must be of type `str`, got `{type(key).__name__}`"
+ warnings.warn(
+ "from fsspec 2023.5 onward FSMap non-str keys will raise TypeError",
+ DeprecationWarning,
+ )
+ if isinstance(key, list):
+ key = tuple(key)
+ key = str(key)
+ return f"{self._root_key_to_str}{key}".rstrip("/")
+
+ def _str_to_key(self, s):
+ """Strip path of to leave key name"""
+ return s[len(self.root) :].lstrip("/")
+
+ def __getitem__(self, key, default=None):
+ """Retrieve data"""
+ k = self._key_to_str(key)
+ try:
+ result = self.fs.cat(k)
+ except self.missing_exceptions:
+ if default is not None:
+ return default
+ raise KeyError(key)
+ return result
+
+ def pop(self, key, default=None):
+ """Pop data"""
+ result = self.__getitem__(key, default)
+ try:
+ del self[key]
+ except KeyError:
+ pass
+ return result
+
+ def __setitem__(self, key, value):
+ """Store value in key"""
+ key = self._key_to_str(key)
+ self.fs.mkdirs(self.fs._parent(key), exist_ok=True)
+ self.fs.pipe_file(key, maybe_convert(value))
+
+ def __iter__(self):
+ return (self._str_to_key(x) for x in self.fs.find(self.root))
+
+ def __len__(self):
+ return len(self.fs.find(self.root))
+
+ def __delitem__(self, key):
+ """Remove key"""
+ try:
+ self.fs.rm(self._key_to_str(key))
+ except: # noqa: E722
+ raise KeyError
+
+ def __contains__(self, key):
+ """Does key exist in mapping?"""
+ path = self._key_to_str(key)
+ return self.fs.isfile(path)
+
+ def __reduce__(self):
+ return FSMap, (self.root, self.fs, False, False, self.missing_exceptions)
+
+
+def maybe_convert(value):
+ if isinstance(value, array.array) or hasattr(value, "__array__"):
+ # bytes-like things
+ if hasattr(value, "dtype") and value.dtype.kind in "Mm":
+ # The buffer interface doesn't support datetime64/timdelta64 numpy
+ # arrays
+ value = value.view("int64")
+ value = bytes(memoryview(value))
+ return value
+
+
+def get_mapper(
+ url="",
+ check=False,
+ create=False,
+ missing_exceptions=None,
+ alternate_root=None,
+ **kwargs,
+):
+ """Create key-value interface for given URL and options
+
+ The URL will be of the form "protocol://location" and point to the root
+ of the mapper required. All keys will be file-names below this location,
+ and their values the contents of each key.
+
+ Also accepts compound URLs like zip::s3://bucket/file.zip , see ``fsspec.open``.
+
+ Parameters
+ ----------
+ url: str
+ Root URL of mapping
+ check: bool
+ Whether to attempt to read from the location before instantiation, to
+ check that the mapping does exist
+ create: bool
+ Whether to make the directory corresponding to the root before
+ instantiating
+ missing_exceptions: None or tuple
+ If given, these exception types will be regarded as missing keys and
+ return KeyError when trying to read data. By default, you get
+ (FileNotFoundError, IsADirectoryError, NotADirectoryError)
+ alternate_root: None or str
+ In cases of complex URLs, the parser may fail to pick the correct part
+ for the mapper root, so this arg can override
+
+ Returns
+ -------
+ ``FSMap`` instance, the dict-like key-value store.
+ """
+ # Removing protocol here - could defer to each open() on the backend
+ fs, urlpath = url_to_fs(url, **kwargs)
+ root = alternate_root if alternate_root is not None else urlpath
+ return FSMap(root, fs, check, create, missing_exceptions=missing_exceptions)
diff --git a/parrot/lib/python3.10/site-packages/fsspec/parquet.py b/parrot/lib/python3.10/site-packages/fsspec/parquet.py
new file mode 100644
index 0000000000000000000000000000000000000000..5a0fb951c427babcd04b0c974a7951b4d331e25b
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/fsspec/parquet.py
@@ -0,0 +1,541 @@
+import io
+import json
+import warnings
+
+from .core import url_to_fs
+from .utils import merge_offset_ranges
+
+# Parquet-Specific Utilities for fsspec
+#
+# Most of the functions defined in this module are NOT
+# intended for public consumption. The only exception
+# to this is `open_parquet_file`, which should be used
+# place of `fs.open()` to open parquet-formatted files
+# on remote file systems.
+
+
+def open_parquet_file(
+ path,
+ mode="rb",
+ fs=None,
+ metadata=None,
+ columns=None,
+ row_groups=None,
+ storage_options=None,
+ strict=False,
+ engine="auto",
+ max_gap=64_000,
+ max_block=256_000_000,
+ footer_sample_size=1_000_000,
+ **kwargs,
+):
+ """
+ Return a file-like object for a single Parquet file.
+
+ The specified parquet `engine` will be used to parse the
+ footer metadata, and determine the required byte ranges
+ from the file. The target path will then be opened with
+ the "parts" (`KnownPartsOfAFile`) caching strategy.
+
+ Note that this method is intended for usage with remote
+ file systems, and is unlikely to improve parquet-read
+ performance on local file systems.
+
+ Parameters
+ ----------
+ path: str
+ Target file path.
+ mode: str, optional
+ Mode option to be passed through to `fs.open`. Default is "rb".
+ metadata: Any, optional
+ Parquet metadata object. Object type must be supported
+ by the backend parquet engine. For now, only the "fastparquet"
+ engine supports an explicit `ParquetFile` metadata object.
+ If a metadata object is supplied, the remote footer metadata
+ will not need to be transferred into local memory.
+ fs: AbstractFileSystem, optional
+ Filesystem object to use for opening the file. If nothing is
+ specified, an `AbstractFileSystem` object will be inferred.
+ engine : str, default "auto"
+ Parquet engine to use for metadata parsing. Allowed options
+ include "fastparquet", "pyarrow", and "auto". The specified
+ engine must be installed in the current environment. If
+ "auto" is specified, and both engines are installed,
+ "fastparquet" will take precedence over "pyarrow".
+ columns: list, optional
+ List of all column names that may be read from the file.
+ row_groups : list, optional
+ List of all row-groups that may be read from the file. This
+ may be a list of row-group indices (integers), or it may be
+ a list of `RowGroup` metadata objects (if the "fastparquet"
+ engine is used).
+ storage_options : dict, optional
+ Used to generate an `AbstractFileSystem` object if `fs` was
+ not specified.
+ strict : bool, optional
+ Whether the resulting `KnownPartsOfAFile` cache should
+ fetch reads that go beyond a known byte-range boundary.
+ If `False` (the default), any read that ends outside a
+ known part will be zero padded. Note that using
+ `strict=True` may be useful for debugging.
+ max_gap : int, optional
+ Neighboring byte ranges will only be merged when their
+ inter-range gap is <= `max_gap`. Default is 64KB.
+ max_block : int, optional
+ Neighboring byte ranges will only be merged when the size of
+ the aggregated range is <= `max_block`. Default is 256MB.
+ footer_sample_size : int, optional
+ Number of bytes to read from the end of the path to look
+ for the footer metadata. If the sampled bytes do not contain
+ the footer, a second read request will be required, and
+ performance will suffer. Default is 1MB.
+ **kwargs :
+ Optional key-word arguments to pass to `fs.open`
+ """
+
+ # Make sure we have an `AbstractFileSystem` object
+ # to work with
+ if fs is None:
+ fs = url_to_fs(path, **(storage_options or {}))[0]
+
+ # For now, `columns == []` not supported. Just use
+ # default `open` command with `path` input
+ if columns is not None and len(columns) == 0:
+ return fs.open(path, mode=mode)
+
+ # Set the engine
+ engine = _set_engine(engine)
+
+ # Fetch the known byte ranges needed to read
+ # `columns` and/or `row_groups`
+ data = _get_parquet_byte_ranges(
+ [path],
+ fs,
+ metadata=metadata,
+ columns=columns,
+ row_groups=row_groups,
+ engine=engine,
+ max_gap=max_gap,
+ max_block=max_block,
+ footer_sample_size=footer_sample_size,
+ )
+
+ # Extract file name from `data`
+ fn = next(iter(data)) if data else path
+
+ # Call self.open with "parts" caching
+ options = kwargs.pop("cache_options", {}).copy()
+ return fs.open(
+ fn,
+ mode=mode,
+ cache_type="parts",
+ cache_options={
+ **options,
+ "data": data.get(fn, {}),
+ "strict": strict,
+ },
+ **kwargs,
+ )
+
+
+def _get_parquet_byte_ranges(
+ paths,
+ fs,
+ metadata=None,
+ columns=None,
+ row_groups=None,
+ max_gap=64_000,
+ max_block=256_000_000,
+ footer_sample_size=1_000_000,
+ engine="auto",
+):
+ """Get a dictionary of the known byte ranges needed
+ to read a specific column/row-group selection from a
+ Parquet dataset. Each value in the output dictionary
+ is intended for use as the `data` argument for the
+ `KnownPartsOfAFile` caching strategy of a single path.
+ """
+
+ # Set engine if necessary
+ if isinstance(engine, str):
+ engine = _set_engine(engine)
+
+ # Pass to specialized function if metadata is defined
+ if metadata is not None:
+ # Use the provided parquet metadata object
+ # to avoid transferring/parsing footer metadata
+ return _get_parquet_byte_ranges_from_metadata(
+ metadata,
+ fs,
+ engine,
+ columns=columns,
+ row_groups=row_groups,
+ max_gap=max_gap,
+ max_block=max_block,
+ )
+
+ # Get file sizes asynchronously
+ file_sizes = fs.sizes(paths)
+
+ # Populate global paths, starts, & ends
+ result = {}
+ data_paths = []
+ data_starts = []
+ data_ends = []
+ add_header_magic = True
+ if columns is None and row_groups is None:
+ # We are NOT selecting specific columns or row-groups.
+ #
+ # We can avoid sampling the footers, and just transfer
+ # all file data with cat_ranges
+ for i, path in enumerate(paths):
+ result[path] = {}
+ for b in range(0, file_sizes[i], max_block):
+ data_paths.append(path)
+ data_starts.append(b)
+ data_ends.append(min(b + max_block, file_sizes[i]))
+ add_header_magic = False # "Magic" should already be included
+ else:
+ # We ARE selecting specific columns or row-groups.
+ #
+ # Gather file footers.
+ # We just take the last `footer_sample_size` bytes of each
+ # file (or the entire file if it is smaller than that)
+ footer_starts = []
+ footer_ends = []
+ for i, path in enumerate(paths):
+ footer_ends.append(file_sizes[i])
+ sample_size = max(0, file_sizes[i] - footer_sample_size)
+ footer_starts.append(sample_size)
+ footer_samples = fs.cat_ranges(paths, footer_starts, footer_ends)
+
+ # Check our footer samples and re-sample if necessary.
+ missing_footer_starts = footer_starts.copy()
+ large_footer = 0
+ for i, path in enumerate(paths):
+ footer_size = int.from_bytes(footer_samples[i][-8:-4], "little")
+ real_footer_start = file_sizes[i] - (footer_size + 8)
+ if real_footer_start < footer_starts[i]:
+ missing_footer_starts[i] = real_footer_start
+ large_footer = max(large_footer, (footer_size + 8))
+ if large_footer:
+ warnings.warn(
+ f"Not enough data was used to sample the parquet footer. "
+ f"Try setting footer_sample_size >= {large_footer}."
+ )
+ for i, block in enumerate(
+ fs.cat_ranges(
+ paths,
+ missing_footer_starts,
+ footer_starts,
+ )
+ ):
+ footer_samples[i] = block + footer_samples[i]
+ footer_starts[i] = missing_footer_starts[i]
+
+ # Calculate required byte ranges for each path
+ for i, path in enumerate(paths):
+ # Deal with small-file case.
+ # Just include all remaining bytes of the file
+ # in a single range.
+ if file_sizes[i] < max_block:
+ if footer_starts[i] > 0:
+ # Only need to transfer the data if the
+ # footer sample isn't already the whole file
+ data_paths.append(path)
+ data_starts.append(0)
+ data_ends.append(footer_starts[i])
+ continue
+
+ # Use "engine" to collect data byte ranges
+ path_data_starts, path_data_ends = engine._parquet_byte_ranges(
+ columns,
+ row_groups=row_groups,
+ footer=footer_samples[i],
+ footer_start=footer_starts[i],
+ )
+
+ data_paths += [path] * len(path_data_starts)
+ data_starts += path_data_starts
+ data_ends += path_data_ends
+
+ # Merge adjacent offset ranges
+ data_paths, data_starts, data_ends = merge_offset_ranges(
+ data_paths,
+ data_starts,
+ data_ends,
+ max_gap=max_gap,
+ max_block=max_block,
+ sort=False, # Should already be sorted
+ )
+
+ # Start by populating `result` with footer samples
+ for i, path in enumerate(paths):
+ result[path] = {(footer_starts[i], footer_ends[i]): footer_samples[i]}
+
+ # Transfer the data byte-ranges into local memory
+ _transfer_ranges(fs, result, data_paths, data_starts, data_ends)
+
+ # Add b"PAR1" to header if necessary
+ if add_header_magic:
+ _add_header_magic(result)
+
+ return result
+
+
+def _get_parquet_byte_ranges_from_metadata(
+ metadata,
+ fs,
+ engine,
+ columns=None,
+ row_groups=None,
+ max_gap=64_000,
+ max_block=256_000_000,
+):
+ """Simplified version of `_get_parquet_byte_ranges` for
+ the case that an engine-specific `metadata` object is
+ provided, and the remote footer metadata does not need to
+ be transferred before calculating the required byte ranges.
+ """
+
+ # Use "engine" to collect data byte ranges
+ data_paths, data_starts, data_ends = engine._parquet_byte_ranges(
+ columns,
+ row_groups=row_groups,
+ metadata=metadata,
+ )
+
+ # Merge adjacent offset ranges
+ data_paths, data_starts, data_ends = merge_offset_ranges(
+ data_paths,
+ data_starts,
+ data_ends,
+ max_gap=max_gap,
+ max_block=max_block,
+ sort=False, # Should be sorted
+ )
+
+ # Transfer the data byte-ranges into local memory
+ result = {fn: {} for fn in list(set(data_paths))}
+ _transfer_ranges(fs, result, data_paths, data_starts, data_ends)
+
+ # Add b"PAR1" to header
+ _add_header_magic(result)
+
+ return result
+
+
+def _transfer_ranges(fs, blocks, paths, starts, ends):
+ # Use cat_ranges to gather the data byte_ranges
+ ranges = (paths, starts, ends)
+ for path, start, stop, data in zip(*ranges, fs.cat_ranges(*ranges)):
+ blocks[path][(start, stop)] = data
+
+
+def _add_header_magic(data):
+ # Add b"PAR1" to file headers
+ for path in list(data.keys()):
+ add_magic = True
+ for k in data[path].keys():
+ if k[0] == 0 and k[1] >= 4:
+ add_magic = False
+ break
+ if add_magic:
+ data[path][(0, 4)] = b"PAR1"
+
+
+def _set_engine(engine_str):
+ # Define a list of parquet engines to try
+ if engine_str == "auto":
+ try_engines = ("fastparquet", "pyarrow")
+ elif not isinstance(engine_str, str):
+ raise ValueError(
+ "Failed to set parquet engine! "
+ "Please pass 'fastparquet', 'pyarrow', or 'auto'"
+ )
+ elif engine_str not in ("fastparquet", "pyarrow"):
+ raise ValueError(f"{engine_str} engine not supported by `fsspec.parquet`")
+ else:
+ try_engines = [engine_str]
+
+ # Try importing the engines in `try_engines`,
+ # and choose the first one that succeeds
+ for engine in try_engines:
+ try:
+ if engine == "fastparquet":
+ return FastparquetEngine()
+ elif engine == "pyarrow":
+ return PyarrowEngine()
+ except ImportError:
+ pass
+
+ # Raise an error if a supported parquet engine
+ # was not found
+ raise ImportError(
+ f"The following parquet engines are not installed "
+ f"in your python environment: {try_engines}."
+ f"Please install 'fastparquert' or 'pyarrow' to "
+ f"utilize the `fsspec.parquet` module."
+ )
+
+
+class FastparquetEngine:
+ # The purpose of the FastparquetEngine class is
+ # to check if fastparquet can be imported (on initialization)
+ # and to define a `_parquet_byte_ranges` method. In the
+ # future, this class may also be used to define other
+ # methods/logic that are specific to fastparquet.
+
+ def __init__(self):
+ import fastparquet as fp
+
+ self.fp = fp
+
+ def _row_group_filename(self, row_group, pf):
+ return pf.row_group_filename(row_group)
+
+ def _parquet_byte_ranges(
+ self,
+ columns,
+ row_groups=None,
+ metadata=None,
+ footer=None,
+ footer_start=None,
+ ):
+ # Initialize offset ranges and define ParqetFile metadata
+ pf = metadata
+ data_paths, data_starts, data_ends = [], [], []
+ if pf is None:
+ pf = self.fp.ParquetFile(io.BytesIO(footer))
+
+ # Convert columns to a set and add any index columns
+ # specified in the pandas metadata (just in case)
+ column_set = None if columns is None else set(columns)
+ if column_set is not None and hasattr(pf, "pandas_metadata"):
+ md_index = [
+ ind
+ for ind in pf.pandas_metadata.get("index_columns", [])
+ # Ignore RangeIndex information
+ if not isinstance(ind, dict)
+ ]
+ column_set |= set(md_index)
+
+ # Check if row_groups is a list of integers
+ # or a list of row-group metadata
+ if row_groups and not isinstance(row_groups[0], int):
+ # Input row_groups contains row-group metadata
+ row_group_indices = None
+ else:
+ # Input row_groups contains row-group indices
+ row_group_indices = row_groups
+ row_groups = pf.row_groups
+
+ # Loop through column chunks to add required byte ranges
+ for r, row_group in enumerate(row_groups):
+ # Skip this row-group if we are targeting
+ # specific row-groups
+ if row_group_indices is None or r in row_group_indices:
+ # Find the target parquet-file path for `row_group`
+ fn = self._row_group_filename(row_group, pf)
+
+ for column in row_group.columns:
+ name = column.meta_data.path_in_schema[0]
+ # Skip this column if we are targeting a
+ # specific columns
+ if column_set is None or name in column_set:
+ file_offset0 = column.meta_data.dictionary_page_offset
+ if file_offset0 is None:
+ file_offset0 = column.meta_data.data_page_offset
+ num_bytes = column.meta_data.total_compressed_size
+ if footer_start is None or file_offset0 < footer_start:
+ data_paths.append(fn)
+ data_starts.append(file_offset0)
+ data_ends.append(
+ min(
+ file_offset0 + num_bytes,
+ footer_start or (file_offset0 + num_bytes),
+ )
+ )
+
+ if metadata:
+ # The metadata in this call may map to multiple
+ # file paths. Need to include `data_paths`
+ return data_paths, data_starts, data_ends
+ return data_starts, data_ends
+
+
+class PyarrowEngine:
+ # The purpose of the PyarrowEngine class is
+ # to check if pyarrow can be imported (on initialization)
+ # and to define a `_parquet_byte_ranges` method. In the
+ # future, this class may also be used to define other
+ # methods/logic that are specific to pyarrow.
+
+ def __init__(self):
+ import pyarrow.parquet as pq
+
+ self.pq = pq
+
+ def _row_group_filename(self, row_group, metadata):
+ raise NotImplementedError
+
+ def _parquet_byte_ranges(
+ self,
+ columns,
+ row_groups=None,
+ metadata=None,
+ footer=None,
+ footer_start=None,
+ ):
+ if metadata is not None:
+ raise ValueError("metadata input not supported for PyarrowEngine")
+
+ data_starts, data_ends = [], []
+ md = self.pq.ParquetFile(io.BytesIO(footer)).metadata
+
+ # Convert columns to a set and add any index columns
+ # specified in the pandas metadata (just in case)
+ column_set = None if columns is None else set(columns)
+ if column_set is not None:
+ schema = md.schema.to_arrow_schema()
+ has_pandas_metadata = (
+ schema.metadata is not None and b"pandas" in schema.metadata
+ )
+ if has_pandas_metadata:
+ md_index = [
+ ind
+ for ind in json.loads(
+ schema.metadata[b"pandas"].decode("utf8")
+ ).get("index_columns", [])
+ # Ignore RangeIndex information
+ if not isinstance(ind, dict)
+ ]
+ column_set |= set(md_index)
+
+ # Loop through column chunks to add required byte ranges
+ for r in range(md.num_row_groups):
+ # Skip this row-group if we are targeting
+ # specific row-groups
+ if row_groups is None or r in row_groups:
+ row_group = md.row_group(r)
+ for c in range(row_group.num_columns):
+ column = row_group.column(c)
+ name = column.path_in_schema
+ # Skip this column if we are targeting a
+ # specific columns
+ split_name = name.split(".")[0]
+ if (
+ column_set is None
+ or name in column_set
+ or split_name in column_set
+ ):
+ file_offset0 = column.dictionary_page_offset
+ if file_offset0 is None:
+ file_offset0 = column.data_page_offset
+ num_bytes = column.total_compressed_size
+ if file_offset0 < footer_start:
+ data_starts.append(file_offset0)
+ data_ends.append(
+ min(file_offset0 + num_bytes, footer_start)
+ )
+ return data_starts, data_ends
diff --git a/parrot/lib/python3.10/site-packages/fsspec/registry.py b/parrot/lib/python3.10/site-packages/fsspec/registry.py
new file mode 100644
index 0000000000000000000000000000000000000000..c261b9b088a72cd94412b6810d4f353b47dea274
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/fsspec/registry.py
@@ -0,0 +1,311 @@
+from __future__ import annotations
+
+import importlib
+import types
+import warnings
+
+__all__ = ["registry", "get_filesystem_class", "default"]
+
+# internal, mutable
+_registry: dict[str, type] = {}
+
+# external, immutable
+registry = types.MappingProxyType(_registry)
+default = "file"
+
+
+def register_implementation(name, cls, clobber=False, errtxt=None):
+ """Add implementation class to the registry
+
+ Parameters
+ ----------
+ name: str
+ Protocol name to associate with the class
+ cls: class or str
+ if a class: fsspec-compliant implementation class (normally inherits from
+ ``fsspec.AbstractFileSystem``, gets added straight to the registry. If a
+ str, the full path to an implementation class like package.module.class,
+ which gets added to known_implementations,
+ so the import is deferred until the filesystem is actually used.
+ clobber: bool (optional)
+ Whether to overwrite a protocol with the same name; if False, will raise
+ instead.
+ errtxt: str (optional)
+ If given, then a failure to import the given class will result in this
+ text being given.
+ """
+ if isinstance(cls, str):
+ if name in known_implementations and clobber is False:
+ if cls != known_implementations[name]["class"]:
+ raise ValueError(
+ f"Name ({name}) already in the known_implementations and clobber "
+ f"is False"
+ )
+ else:
+ known_implementations[name] = {
+ "class": cls,
+ "err": errtxt or f"{cls} import failed for protocol {name}",
+ }
+
+ else:
+ if name in registry and clobber is False:
+ if _registry[name] is not cls:
+ raise ValueError(
+ f"Name ({name}) already in the registry and clobber is False"
+ )
+ else:
+ _registry[name] = cls
+
+
+# protocols mapped to the class which implements them. This dict can be
+# updated with register_implementation
+known_implementations = {
+ "abfs": {
+ "class": "adlfs.AzureBlobFileSystem",
+ "err": "Install adlfs to access Azure Datalake Gen2 and Azure Blob Storage",
+ },
+ "adl": {
+ "class": "adlfs.AzureDatalakeFileSystem",
+ "err": "Install adlfs to access Azure Datalake Gen1",
+ },
+ "arrow_hdfs": {
+ "class": "fsspec.implementations.arrow.HadoopFileSystem",
+ "err": "pyarrow and local java libraries required for HDFS",
+ },
+ "asynclocal": {
+ "class": "morefs.asyn_local.AsyncLocalFileSystem",
+ "err": "Install 'morefs[asynclocalfs]' to use AsyncLocalFileSystem",
+ },
+ "az": {
+ "class": "adlfs.AzureBlobFileSystem",
+ "err": "Install adlfs to access Azure Datalake Gen2 and Azure Blob Storage",
+ },
+ "blockcache": {"class": "fsspec.implementations.cached.CachingFileSystem"},
+ "box": {
+ "class": "boxfs.BoxFileSystem",
+ "err": "Please install boxfs to access BoxFileSystem",
+ },
+ "cached": {"class": "fsspec.implementations.cached.CachingFileSystem"},
+ "dask": {
+ "class": "fsspec.implementations.dask.DaskWorkerFileSystem",
+ "err": "Install dask distributed to access worker file system",
+ },
+ "data": {"class": "fsspec.implementations.data.DataFileSystem"},
+ "dbfs": {
+ "class": "fsspec.implementations.dbfs.DatabricksFileSystem",
+ "err": "Install the requests package to use the DatabricksFileSystem",
+ },
+ "dir": {"class": "fsspec.implementations.dirfs.DirFileSystem"},
+ "dropbox": {
+ "class": "dropboxdrivefs.DropboxDriveFileSystem",
+ "err": (
+ 'DropboxFileSystem requires "dropboxdrivefs","requests" and "'
+ '"dropbox" to be installed'
+ ),
+ },
+ "dvc": {
+ "class": "dvc.api.DVCFileSystem",
+ "err": "Install dvc to access DVCFileSystem",
+ },
+ "file": {"class": "fsspec.implementations.local.LocalFileSystem"},
+ "filecache": {"class": "fsspec.implementations.cached.WholeFileCacheFileSystem"},
+ "ftp": {"class": "fsspec.implementations.ftp.FTPFileSystem"},
+ "gcs": {
+ "class": "gcsfs.GCSFileSystem",
+ "err": "Please install gcsfs to access Google Storage",
+ },
+ "gdrive": {
+ "class": "gdrivefs.GoogleDriveFileSystem",
+ "err": "Please install gdrivefs for access to Google Drive",
+ },
+ "generic": {"class": "fsspec.generic.GenericFileSystem"},
+ "git": {
+ "class": "fsspec.implementations.git.GitFileSystem",
+ "err": "Install pygit2 to browse local git repos",
+ },
+ "github": {
+ "class": "fsspec.implementations.github.GithubFileSystem",
+ "err": "Install the requests package to use the github FS",
+ },
+ "gs": {
+ "class": "gcsfs.GCSFileSystem",
+ "err": "Please install gcsfs to access Google Storage",
+ },
+ "hdfs": {
+ "class": "fsspec.implementations.arrow.HadoopFileSystem",
+ "err": "pyarrow and local java libraries required for HDFS",
+ },
+ "hf": {
+ "class": "huggingface_hub.HfFileSystem",
+ "err": "Install huggingface_hub to access HfFileSystem",
+ },
+ "http": {
+ "class": "fsspec.implementations.http.HTTPFileSystem",
+ "err": 'HTTPFileSystem requires "requests" and "aiohttp" to be installed',
+ },
+ "https": {
+ "class": "fsspec.implementations.http.HTTPFileSystem",
+ "err": 'HTTPFileSystem requires "requests" and "aiohttp" to be installed',
+ },
+ "jlab": {
+ "class": "fsspec.implementations.jupyter.JupyterFileSystem",
+ "err": "Jupyter FS requires requests to be installed",
+ },
+ "jupyter": {
+ "class": "fsspec.implementations.jupyter.JupyterFileSystem",
+ "err": "Jupyter FS requires requests to be installed",
+ },
+ "lakefs": {
+ "class": "lakefs_spec.LakeFSFileSystem",
+ "err": "Please install lakefs-spec to access LakeFSFileSystem",
+ },
+ "libarchive": {
+ "class": "fsspec.implementations.libarchive.LibArchiveFileSystem",
+ "err": "LibArchive requires to be installed",
+ },
+ "local": {"class": "fsspec.implementations.local.LocalFileSystem"},
+ "memory": {"class": "fsspec.implementations.memory.MemoryFileSystem"},
+ "oci": {
+ "class": "ocifs.OCIFileSystem",
+ "err": "Install ocifs to access OCI Object Storage",
+ },
+ "ocilake": {
+ "class": "ocifs.OCIFileSystem",
+ "err": "Install ocifs to access OCI Data Lake",
+ },
+ "oss": {
+ "class": "ossfs.OSSFileSystem",
+ "err": "Install ossfs to access Alibaba Object Storage System",
+ },
+ "reference": {"class": "fsspec.implementations.reference.ReferenceFileSystem"},
+ "root": {
+ "class": "fsspec_xrootd.XRootDFileSystem",
+ "err": (
+ "Install fsspec-xrootd to access xrootd storage system. "
+ "Note: 'root' is the protocol name for xrootd storage systems, "
+ "not referring to root directories"
+ ),
+ },
+ "s3": {"class": "s3fs.S3FileSystem", "err": "Install s3fs to access S3"},
+ "s3a": {"class": "s3fs.S3FileSystem", "err": "Install s3fs to access S3"},
+ "sftp": {
+ "class": "fsspec.implementations.sftp.SFTPFileSystem",
+ "err": 'SFTPFileSystem requires "paramiko" to be installed',
+ },
+ "simplecache": {"class": "fsspec.implementations.cached.SimpleCacheFileSystem"},
+ "smb": {
+ "class": "fsspec.implementations.smb.SMBFileSystem",
+ "err": 'SMB requires "smbprotocol" or "smbprotocol[kerberos]" installed',
+ },
+ "ssh": {
+ "class": "fsspec.implementations.sftp.SFTPFileSystem",
+ "err": 'SFTPFileSystem requires "paramiko" to be installed',
+ },
+ "tar": {"class": "fsspec.implementations.tar.TarFileSystem"},
+ "wandb": {"class": "wandbfs.WandbFS", "err": "Install wandbfs to access wandb"},
+ "webdav": {
+ "class": "webdav4.fsspec.WebdavFileSystem",
+ "err": "Install webdav4 to access WebDAV",
+ },
+ "webhdfs": {
+ "class": "fsspec.implementations.webhdfs.WebHDFS",
+ "err": 'webHDFS access requires "requests" to be installed',
+ },
+ "zip": {"class": "fsspec.implementations.zip.ZipFileSystem"},
+}
+
+assert list(known_implementations) == sorted(
+ known_implementations
+), "Not in alphabetical order"
+
+
+def get_filesystem_class(protocol):
+ """Fetch named protocol implementation from the registry
+
+ The dict ``known_implementations`` maps protocol names to the locations
+ of classes implementing the corresponding file-system. When used for the
+ first time, appropriate imports will happen and the class will be placed in
+ the registry. All subsequent calls will fetch directly from the registry.
+
+ Some protocol implementations require additional dependencies, and so the
+ import may fail. In this case, the string in the "err" field of the
+ ``known_implementations`` will be given as the error message.
+ """
+ if not protocol:
+ protocol = default
+
+ if protocol not in registry:
+ if protocol not in known_implementations:
+ raise ValueError(f"Protocol not known: {protocol}")
+ bit = known_implementations[protocol]
+ try:
+ register_implementation(protocol, _import_class(bit["class"]))
+ except ImportError as e:
+ raise ImportError(bit["err"]) from e
+ cls = registry[protocol]
+ if getattr(cls, "protocol", None) in ("abstract", None):
+ cls.protocol = protocol
+
+ return cls
+
+
+s3_msg = """Your installed version of s3fs is very old and known to cause
+severe performance issues, see also https://github.com/dask/dask/issues/10276
+
+To fix, you should specify a lower version bound on s3fs, or
+update the current installation.
+"""
+
+
+def _import_class(fqp: str):
+ """Take a fully-qualified path and return the imported class or identifier.
+
+ ``fqp`` is of the form "package.module.klass" or
+ "package.module:subobject.klass".
+
+ Warnings
+ --------
+ This can import arbitrary modules. Make sure you haven't installed any modules
+ that may execute malicious code at import time.
+ """
+ if ":" in fqp:
+ mod, name = fqp.rsplit(":", 1)
+ else:
+ mod, name = fqp.rsplit(".", 1)
+
+ is_s3 = mod == "s3fs"
+ mod = importlib.import_module(mod)
+ if is_s3 and mod.__version__.split(".") < ["0", "5"]:
+ warnings.warn(s3_msg)
+ for part in name.split("."):
+ mod = getattr(mod, part)
+
+ if not isinstance(mod, type):
+ raise TypeError(f"{fqp} is not a class")
+
+ return mod
+
+
+def filesystem(protocol, **storage_options):
+ """Instantiate filesystems for given protocol and arguments
+
+ ``storage_options`` are specific to the protocol being chosen, and are
+ passed directly to the class.
+ """
+ if protocol == "arrow_hdfs":
+ warnings.warn(
+ "The 'arrow_hdfs' protocol has been deprecated and will be "
+ "removed in the future. Specify it as 'hdfs'.",
+ DeprecationWarning,
+ )
+
+ cls = get_filesystem_class(protocol)
+ return cls(**storage_options)
+
+
+def available_protocols():
+ """Return a list of the implemented protocols.
+
+ Note that any given protocol may require extra packages to be importable.
+ """
+ return list(known_implementations)
diff --git a/parrot/lib/python3.10/site-packages/fsspec/spec.py b/parrot/lib/python3.10/site-packages/fsspec/spec.py
new file mode 100644
index 0000000000000000000000000000000000000000..1463a4499988e45ddfb1c3f561f90a4e57229713
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/fsspec/spec.py
@@ -0,0 +1,2068 @@
+from __future__ import annotations
+
+import io
+import json
+import logging
+import os
+import threading
+import warnings
+import weakref
+from errno import ESPIPE
+from glob import has_magic
+from hashlib import sha256
+from typing import Any, ClassVar, Dict, Tuple
+
+from .callbacks import DEFAULT_CALLBACK
+from .config import apply_config, conf
+from .dircache import DirCache
+from .transaction import Transaction
+from .utils import (
+ _unstrip_protocol,
+ glob_translate,
+ isfilelike,
+ other_paths,
+ read_block,
+ stringify_path,
+ tokenize,
+)
+
+logger = logging.getLogger("fsspec")
+
+
+def make_instance(cls, args, kwargs):
+ return cls(*args, **kwargs)
+
+
+class _Cached(type):
+ """
+ Metaclass for caching file system instances.
+
+ Notes
+ -----
+ Instances are cached according to
+
+ * The values of the class attributes listed in `_extra_tokenize_attributes`
+ * The arguments passed to ``__init__``.
+
+ This creates an additional reference to the filesystem, which prevents the
+ filesystem from being garbage collected when all *user* references go away.
+ A call to the :meth:`AbstractFileSystem.clear_instance_cache` must *also*
+ be made for a filesystem instance to be garbage collected.
+ """
+
+ def __init__(cls, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+ # Note: we intentionally create a reference here, to avoid garbage
+ # collecting instances when all other references are gone. To really
+ # delete a FileSystem, the cache must be cleared.
+ if conf.get("weakref_instance_cache"): # pragma: no cover
+ # debug option for analysing fork/spawn conditions
+ cls._cache = weakref.WeakValueDictionary()
+ else:
+ cls._cache = {}
+ cls._pid = os.getpid()
+
+ def __call__(cls, *args, **kwargs):
+ kwargs = apply_config(cls, kwargs)
+ extra_tokens = tuple(
+ getattr(cls, attr, None) for attr in cls._extra_tokenize_attributes
+ )
+ token = tokenize(
+ cls, cls._pid, threading.get_ident(), *args, *extra_tokens, **kwargs
+ )
+ skip = kwargs.pop("skip_instance_cache", False)
+ if os.getpid() != cls._pid:
+ cls._cache.clear()
+ cls._pid = os.getpid()
+ if not skip and cls.cachable and token in cls._cache:
+ cls._latest = token
+ return cls._cache[token]
+ else:
+ obj = super().__call__(*args, **kwargs)
+ # Setting _fs_token here causes some static linters to complain.
+ obj._fs_token_ = token
+ obj.storage_args = args
+ obj.storage_options = kwargs
+ if obj.async_impl and obj.mirror_sync_methods:
+ from .asyn import mirror_sync_methods
+
+ mirror_sync_methods(obj)
+
+ if cls.cachable and not skip:
+ cls._latest = token
+ cls._cache[token] = obj
+ return obj
+
+
+class AbstractFileSystem(metaclass=_Cached):
+ """
+ An abstract super-class for pythonic file-systems
+
+ Implementations are expected to be compatible with or, better, subclass
+ from here.
+ """
+
+ cachable = True # this class can be cached, instances reused
+ _cached = False
+ blocksize = 2**22
+ sep = "/"
+ protocol: ClassVar[str | tuple[str, ...]] = "abstract"
+ _latest = None
+ async_impl = False
+ mirror_sync_methods = False
+ root_marker = "" # For some FSs, may require leading '/' or other character
+ transaction_type = Transaction
+
+ #: Extra *class attributes* that should be considered when hashing.
+ _extra_tokenize_attributes = ()
+
+ # Set by _Cached metaclass
+ storage_args: Tuple[Any, ...]
+ storage_options: Dict[str, Any]
+
+ def __init__(self, *args, **storage_options):
+ """Create and configure file-system instance
+
+ Instances may be cachable, so if similar enough arguments are seen
+ a new instance is not required. The token attribute exists to allow
+ implementations to cache instances if they wish.
+
+ A reasonable default should be provided if there are no arguments.
+
+ Subclasses should call this method.
+
+ Parameters
+ ----------
+ use_listings_cache, listings_expiry_time, max_paths:
+ passed to ``DirCache``, if the implementation supports
+ directory listing caching. Pass use_listings_cache=False
+ to disable such caching.
+ skip_instance_cache: bool
+ If this is a cachable implementation, pass True here to force
+ creating a new instance even if a matching instance exists, and prevent
+ storing this instance.
+ asynchronous: bool
+ loop: asyncio-compatible IOLoop or None
+ """
+ if self._cached:
+ # reusing instance, don't change
+ return
+ self._cached = True
+ self._intrans = False
+ self._transaction = None
+ self._invalidated_caches_in_transaction = []
+ self.dircache = DirCache(**storage_options)
+
+ if storage_options.pop("add_docs", None):
+ warnings.warn("add_docs is no longer supported.", FutureWarning)
+
+ if storage_options.pop("add_aliases", None):
+ warnings.warn("add_aliases has been removed.", FutureWarning)
+ # This is set in _Cached
+ self._fs_token_ = None
+
+ @property
+ def fsid(self):
+ """Persistent filesystem id that can be used to compare filesystems
+ across sessions.
+ """
+ raise NotImplementedError
+
+ @property
+ def _fs_token(self):
+ return self._fs_token_
+
+ def __dask_tokenize__(self):
+ return self._fs_token
+
+ def __hash__(self):
+ return int(self._fs_token, 16)
+
+ def __eq__(self, other):
+ return isinstance(other, type(self)) and self._fs_token == other._fs_token
+
+ def __reduce__(self):
+ return make_instance, (type(self), self.storage_args, self.storage_options)
+
+ @classmethod
+ def _strip_protocol(cls, path):
+ """Turn path from fully-qualified to file-system-specific
+
+ May require FS-specific handling, e.g., for relative paths or links.
+ """
+ if isinstance(path, list):
+ return [cls._strip_protocol(p) for p in path]
+ path = stringify_path(path)
+ protos = (cls.protocol,) if isinstance(cls.protocol, str) else cls.protocol
+ for protocol in protos:
+ if path.startswith(protocol + "://"):
+ path = path[len(protocol) + 3 :]
+ elif path.startswith(protocol + "::"):
+ path = path[len(protocol) + 2 :]
+ path = path.rstrip("/")
+ # use of root_marker to make minimum required path, e.g., "/"
+ return path or cls.root_marker
+
+ def unstrip_protocol(self, name: str) -> str:
+ """Format FS-specific path to generic, including protocol"""
+ protos = (self.protocol,) if isinstance(self.protocol, str) else self.protocol
+ for protocol in protos:
+ if name.startswith(f"{protocol}://"):
+ return name
+ return f"{protos[0]}://{name}"
+
+ @staticmethod
+ def _get_kwargs_from_urls(path):
+ """If kwargs can be encoded in the paths, extract them here
+
+ This should happen before instantiation of the class; incoming paths
+ then should be amended to strip the options in methods.
+
+ Examples may look like an sftp path "sftp://user@host:/my/path", where
+ the user and host should become kwargs and later get stripped.
+ """
+ # by default, nothing happens
+ return {}
+
+ @classmethod
+ def current(cls):
+ """Return the most recently instantiated FileSystem
+
+ If no instance has been created, then create one with defaults
+ """
+ if cls._latest in cls._cache:
+ return cls._cache[cls._latest]
+ return cls()
+
+ @property
+ def transaction(self):
+ """A context within which files are committed together upon exit
+
+ Requires the file class to implement `.commit()` and `.discard()`
+ for the normal and exception cases.
+ """
+ if self._transaction is None:
+ self._transaction = self.transaction_type(self)
+ return self._transaction
+
+ def start_transaction(self):
+ """Begin write transaction for deferring files, non-context version"""
+ self._intrans = True
+ self._transaction = self.transaction_type(self)
+ return self.transaction
+
+ def end_transaction(self):
+ """Finish write transaction, non-context version"""
+ self.transaction.complete()
+ self._transaction = None
+ # The invalid cache must be cleared after the transaction is completed.
+ for path in self._invalidated_caches_in_transaction:
+ self.invalidate_cache(path)
+ self._invalidated_caches_in_transaction.clear()
+
+ def invalidate_cache(self, path=None):
+ """
+ Discard any cached directory information
+
+ Parameters
+ ----------
+ path: string or None
+ If None, clear all listings cached else listings at or under given
+ path.
+ """
+ # Not necessary to implement invalidation mechanism, may have no cache.
+ # But if have, you should call this method of parent class from your
+ # subclass to ensure expiring caches after transacations correctly.
+ # See the implementation of FTPFileSystem in ftp.py
+ if self._intrans:
+ self._invalidated_caches_in_transaction.append(path)
+
+ def mkdir(self, path, create_parents=True, **kwargs):
+ """
+ Create directory entry at path
+
+ For systems that don't have true directories, may create an for
+ this instance only and not touch the real filesystem
+
+ Parameters
+ ----------
+ path: str
+ location
+ create_parents: bool
+ if True, this is equivalent to ``makedirs``
+ kwargs:
+ may be permissions, etc.
+ """
+ pass # not necessary to implement, may not have directories
+
+ def makedirs(self, path, exist_ok=False):
+ """Recursively make directories
+
+ Creates directory at path and any intervening required directories.
+ Raises exception if, for instance, the path already exists but is a
+ file.
+
+ Parameters
+ ----------
+ path: str
+ leaf directory name
+ exist_ok: bool (False)
+ If False, will error if the target already exists
+ """
+ pass # not necessary to implement, may not have directories
+
+ def rmdir(self, path):
+ """Remove a directory, if empty"""
+ pass # not necessary to implement, may not have directories
+
+ def ls(self, path, detail=True, **kwargs):
+ """List objects at path.
+
+ This should include subdirectories and files at that location. The
+ difference between a file and a directory must be clear when details
+ are requested.
+
+ The specific keys, or perhaps a FileInfo class, or similar, is TBD,
+ but must be consistent across implementations.
+ Must include:
+
+ - full path to the entry (without protocol)
+ - size of the entry, in bytes. If the value cannot be determined, will
+ be ``None``.
+ - type of entry, "file", "directory" or other
+
+ Additional information
+ may be present, appropriate to the file-system, e.g., generation,
+ checksum, etc.
+
+ May use refresh=True|False to allow use of self._ls_from_cache to
+ check for a saved listing and avoid calling the backend. This would be
+ common where listing may be expensive.
+
+ Parameters
+ ----------
+ path: str
+ detail: bool
+ if True, gives a list of dictionaries, where each is the same as
+ the result of ``info(path)``. If False, gives a list of paths
+ (str).
+ kwargs: may have additional backend-specific options, such as version
+ information
+
+ Returns
+ -------
+ List of strings if detail is False, or list of directory information
+ dicts if detail is True.
+ """
+ raise NotImplementedError
+
+ def _ls_from_cache(self, path):
+ """Check cache for listing
+
+ Returns listing, if found (may be empty list for a directly that exists
+ but contains nothing), None if not in cache.
+ """
+ parent = self._parent(path)
+ try:
+ return self.dircache[path.rstrip("/")]
+ except KeyError:
+ pass
+ try:
+ files = [
+ f
+ for f in self.dircache[parent]
+ if f["name"] == path
+ or (f["name"] == path.rstrip("/") and f["type"] == "directory")
+ ]
+ if len(files) == 0:
+ # parent dir was listed but did not contain this file
+ raise FileNotFoundError(path)
+ return files
+ except KeyError:
+ pass
+
+ def walk(self, path, maxdepth=None, topdown=True, on_error="omit", **kwargs):
+ """Return all files belows path
+
+ List all files, recursing into subdirectories; output is iterator-style,
+ like ``os.walk()``. For a simple list of files, ``find()`` is available.
+
+ When topdown is True, the caller can modify the dirnames list in-place (perhaps
+ using del or slice assignment), and walk() will
+ only recurse into the subdirectories whose names remain in dirnames;
+ this can be used to prune the search, impose a specific order of visiting,
+ or even to inform walk() about directories the caller creates or renames before
+ it resumes walk() again.
+ Modifying dirnames when topdown is False has no effect. (see os.walk)
+
+ Note that the "files" outputted will include anything that is not
+ a directory, such as links.
+
+ Parameters
+ ----------
+ path: str
+ Root to recurse into
+ maxdepth: int
+ Maximum recursion depth. None means limitless, but not recommended
+ on link-based file-systems.
+ topdown: bool (True)
+ Whether to walk the directory tree from the top downwards or from
+ the bottom upwards.
+ on_error: "omit", "raise", a collable
+ if omit (default), path with exception will simply be empty;
+ If raise, an underlying exception will be raised;
+ if callable, it will be called with a single OSError instance as argument
+ kwargs: passed to ``ls``
+ """
+ if maxdepth is not None and maxdepth < 1:
+ raise ValueError("maxdepth must be at least 1")
+
+ path = self._strip_protocol(path)
+ full_dirs = {}
+ dirs = {}
+ files = {}
+
+ detail = kwargs.pop("detail", False)
+ try:
+ listing = self.ls(path, detail=True, **kwargs)
+ except (FileNotFoundError, OSError) as e:
+ if on_error == "raise":
+ raise
+ elif callable(on_error):
+ on_error(e)
+ if detail:
+ return path, {}, {}
+ return path, [], []
+
+ for info in listing:
+ # each info name must be at least [path]/part , but here
+ # we check also for names like [path]/part/
+ pathname = info["name"].rstrip("/")
+ name = pathname.rsplit("/", 1)[-1]
+ if info["type"] == "directory" and pathname != path:
+ # do not include "self" path
+ full_dirs[name] = pathname
+ dirs[name] = info
+ elif pathname == path:
+ # file-like with same name as give path
+ files[""] = info
+ else:
+ files[name] = info
+
+ if not detail:
+ dirs = list(dirs)
+ files = list(files)
+
+ if topdown:
+ # Yield before recursion if walking top down
+ yield path, dirs, files
+
+ if maxdepth is not None:
+ maxdepth -= 1
+ if maxdepth < 1:
+ if not topdown:
+ yield path, dirs, files
+ return
+
+ for d in dirs:
+ yield from self.walk(
+ full_dirs[d],
+ maxdepth=maxdepth,
+ detail=detail,
+ topdown=topdown,
+ **kwargs,
+ )
+
+ if not topdown:
+ # Yield after recursion if walking bottom up
+ yield path, dirs, files
+
+ def find(self, path, maxdepth=None, withdirs=False, detail=False, **kwargs):
+ """List all files below path.
+
+ Like posix ``find`` command without conditions
+
+ Parameters
+ ----------
+ path : str
+ maxdepth: int or None
+ If not None, the maximum number of levels to descend
+ withdirs: bool
+ Whether to include directory paths in the output. This is True
+ when used by glob, but users usually only want files.
+ kwargs are passed to ``ls``.
+ """
+ # TODO: allow equivalent of -name parameter
+ path = self._strip_protocol(path)
+ out = {}
+
+ # Add the root directory if withdirs is requested
+ # This is needed for posix glob compliance
+ if withdirs and path != "" and self.isdir(path):
+ out[path] = self.info(path)
+
+ for _, dirs, files in self.walk(path, maxdepth, detail=True, **kwargs):
+ if withdirs:
+ files.update(dirs)
+ out.update({info["name"]: info for name, info in files.items()})
+ if not out and self.isfile(path):
+ # walk works on directories, but find should also return [path]
+ # when path happens to be a file
+ out[path] = {}
+ names = sorted(out)
+ if not detail:
+ return names
+ else:
+ return {name: out[name] for name in names}
+
+ def du(self, path, total=True, maxdepth=None, withdirs=False, **kwargs):
+ """Space used by files and optionally directories within a path
+
+ Directory size does not include the size of its contents.
+
+ Parameters
+ ----------
+ path: str
+ total: bool
+ Whether to sum all the file sizes
+ maxdepth: int or None
+ Maximum number of directory levels to descend, None for unlimited.
+ withdirs: bool
+ Whether to include directory paths in the output.
+ kwargs: passed to ``find``
+
+ Returns
+ -------
+ Dict of {path: size} if total=False, or int otherwise, where numbers
+ refer to bytes used.
+ """
+ sizes = {}
+ if withdirs and self.isdir(path):
+ # Include top-level directory in output
+ info = self.info(path)
+ sizes[info["name"]] = info["size"]
+ for f in self.find(path, maxdepth=maxdepth, withdirs=withdirs, **kwargs):
+ info = self.info(f)
+ sizes[info["name"]] = info["size"]
+ if total:
+ return sum(sizes.values())
+ else:
+ return sizes
+
+ def glob(self, path, maxdepth=None, **kwargs):
+ """
+ Find files by glob-matching.
+
+ If the path ends with '/', only folders are returned.
+
+ We support ``"**"``,
+ ``"?"`` and ``"[..]"``. We do not support ^ for pattern negation.
+
+ The `maxdepth` option is applied on the first `**` found in the path.
+
+ kwargs are passed to ``ls``.
+ """
+ if maxdepth is not None and maxdepth < 1:
+ raise ValueError("maxdepth must be at least 1")
+
+ import re
+
+ seps = (os.path.sep, os.path.altsep) if os.path.altsep else (os.path.sep,)
+ ends_with_sep = path.endswith(seps) # _strip_protocol strips trailing slash
+ path = self._strip_protocol(path)
+ append_slash_to_dirname = ends_with_sep or path.endswith(
+ tuple(sep + "**" for sep in seps)
+ )
+ idx_star = path.find("*") if path.find("*") >= 0 else len(path)
+ idx_qmark = path.find("?") if path.find("?") >= 0 else len(path)
+ idx_brace = path.find("[") if path.find("[") >= 0 else len(path)
+
+ min_idx = min(idx_star, idx_qmark, idx_brace)
+
+ detail = kwargs.pop("detail", False)
+
+ if not has_magic(path):
+ if self.exists(path, **kwargs):
+ if not detail:
+ return [path]
+ else:
+ return {path: self.info(path, **kwargs)}
+ else:
+ if not detail:
+ return [] # glob of non-existent returns empty
+ else:
+ return {}
+ elif "/" in path[:min_idx]:
+ min_idx = path[:min_idx].rindex("/")
+ root = path[: min_idx + 1]
+ depth = path[min_idx + 1 :].count("/") + 1
+ else:
+ root = ""
+ depth = path[min_idx + 1 :].count("/") + 1
+
+ if "**" in path:
+ if maxdepth is not None:
+ idx_double_stars = path.find("**")
+ depth_double_stars = path[idx_double_stars:].count("/") + 1
+ depth = depth - depth_double_stars + maxdepth
+ else:
+ depth = None
+
+ allpaths = self.find(root, maxdepth=depth, withdirs=True, detail=True, **kwargs)
+
+ pattern = glob_translate(path + ("/" if ends_with_sep else ""))
+ pattern = re.compile(pattern)
+
+ out = {
+ p: info
+ for p, info in sorted(allpaths.items())
+ if pattern.match(
+ (
+ p + "/"
+ if append_slash_to_dirname and info["type"] == "directory"
+ else p
+ )
+ )
+ }
+
+ if detail:
+ return out
+ else:
+ return list(out)
+
+ def exists(self, path, **kwargs):
+ """Is there a file at the given path"""
+ try:
+ self.info(path, **kwargs)
+ return True
+ except: # noqa: E722
+ # any exception allowed bar FileNotFoundError?
+ return False
+
+ def lexists(self, path, **kwargs):
+ """If there is a file at the given path (including
+ broken links)"""
+ return self.exists(path)
+
+ def info(self, path, **kwargs):
+ """Give details of entry at path
+
+ Returns a single dictionary, with exactly the same information as ``ls``
+ would with ``detail=True``.
+
+ The default implementation should calls ls and could be overridden by a
+ shortcut. kwargs are passed on to ```ls()``.
+
+ Some file systems might not be able to measure the file's size, in
+ which case, the returned dict will include ``'size': None``.
+
+ Returns
+ -------
+ dict with keys: name (full path in the FS), size (in bytes), type (file,
+ directory, or something else) and other FS-specific keys.
+ """
+ path = self._strip_protocol(path)
+ out = self.ls(self._parent(path), detail=True, **kwargs)
+ out = [o for o in out if o["name"].rstrip("/") == path]
+ if out:
+ return out[0]
+ out = self.ls(path, detail=True, **kwargs)
+ path = path.rstrip("/")
+ out1 = [o for o in out if o["name"].rstrip("/") == path]
+ if len(out1) == 1:
+ if "size" not in out1[0]:
+ out1[0]["size"] = None
+ return out1[0]
+ elif len(out1) > 1 or out:
+ return {"name": path, "size": 0, "type": "directory"}
+ else:
+ raise FileNotFoundError(path)
+
+ def checksum(self, path):
+ """Unique value for current version of file
+
+ If the checksum is the same from one moment to another, the contents
+ are guaranteed to be the same. If the checksum changes, the contents
+ *might* have changed.
+
+ This should normally be overridden; default will probably capture
+ creation/modification timestamp (which would be good) or maybe
+ access timestamp (which would be bad)
+ """
+ return int(tokenize(self.info(path)), 16)
+
+ def size(self, path):
+ """Size in bytes of file"""
+ return self.info(path).get("size", None)
+
+ def sizes(self, paths):
+ """Size in bytes of each file in a list of paths"""
+ return [self.size(p) for p in paths]
+
+ def isdir(self, path):
+ """Is this entry directory-like?"""
+ try:
+ return self.info(path)["type"] == "directory"
+ except OSError:
+ return False
+
+ def isfile(self, path):
+ """Is this entry file-like?"""
+ try:
+ return self.info(path)["type"] == "file"
+ except: # noqa: E722
+ return False
+
+ def read_text(self, path, encoding=None, errors=None, newline=None, **kwargs):
+ """Get the contents of the file as a string.
+
+ Parameters
+ ----------
+ path: str
+ URL of file on this filesystems
+ encoding, errors, newline: same as `open`.
+ """
+ with self.open(
+ path,
+ mode="r",
+ encoding=encoding,
+ errors=errors,
+ newline=newline,
+ **kwargs,
+ ) as f:
+ return f.read()
+
+ def write_text(
+ self, path, value, encoding=None, errors=None, newline=None, **kwargs
+ ):
+ """Write the text to the given file.
+
+ An existing file will be overwritten.
+
+ Parameters
+ ----------
+ path: str
+ URL of file on this filesystems
+ value: str
+ Text to write.
+ encoding, errors, newline: same as `open`.
+ """
+ with self.open(
+ path,
+ mode="w",
+ encoding=encoding,
+ errors=errors,
+ newline=newline,
+ **kwargs,
+ ) as f:
+ return f.write(value)
+
+ def cat_file(self, path, start=None, end=None, **kwargs):
+ """Get the content of a file
+
+ Parameters
+ ----------
+ path: URL of file on this filesystems
+ start, end: int
+ Bytes limits of the read. If negative, backwards from end,
+ like usual python slices. Either can be None for start or
+ end of file, respectively
+ kwargs: passed to ``open()``.
+ """
+ # explicitly set buffering off?
+ with self.open(path, "rb", **kwargs) as f:
+ if start is not None:
+ if start >= 0:
+ f.seek(start)
+ else:
+ f.seek(max(0, f.size + start))
+ if end is not None:
+ if end < 0:
+ end = f.size + end
+ return f.read(end - f.tell())
+ return f.read()
+
+ def pipe_file(self, path, value, **kwargs):
+ """Set the bytes of given file"""
+ with self.open(path, "wb", **kwargs) as f:
+ f.write(value)
+
+ def pipe(self, path, value=None, **kwargs):
+ """Put value into path
+
+ (counterpart to ``cat``)
+
+ Parameters
+ ----------
+ path: string or dict(str, bytes)
+ If a string, a single remote location to put ``value`` bytes; if a dict,
+ a mapping of {path: bytesvalue}.
+ value: bytes, optional
+ If using a single path, these are the bytes to put there. Ignored if
+ ``path`` is a dict
+ """
+ if isinstance(path, str):
+ self.pipe_file(self._strip_protocol(path), value, **kwargs)
+ elif isinstance(path, dict):
+ for k, v in path.items():
+ self.pipe_file(self._strip_protocol(k), v, **kwargs)
+ else:
+ raise ValueError("path must be str or dict")
+
+ def cat_ranges(
+ self, paths, starts, ends, max_gap=None, on_error="return", **kwargs
+ ):
+ """Get the contents of byte ranges from one or more files
+
+ Parameters
+ ----------
+ paths: list
+ A list of of filepaths on this filesystems
+ starts, ends: int or list
+ Bytes limits of the read. If using a single int, the same value will be
+ used to read all the specified files.
+ """
+ if max_gap is not None:
+ raise NotImplementedError
+ if not isinstance(paths, list):
+ raise TypeError
+ if not isinstance(starts, list):
+ starts = [starts] * len(paths)
+ if not isinstance(ends, list):
+ ends = [ends] * len(paths)
+ if len(starts) != len(paths) or len(ends) != len(paths):
+ raise ValueError
+ out = []
+ for p, s, e in zip(paths, starts, ends):
+ try:
+ out.append(self.cat_file(p, s, e))
+ except Exception as e:
+ if on_error == "return":
+ out.append(e)
+ else:
+ raise
+ return out
+
+ def cat(self, path, recursive=False, on_error="raise", **kwargs):
+ """Fetch (potentially multiple) paths' contents
+
+ Parameters
+ ----------
+ recursive: bool
+ If True, assume the path(s) are directories, and get all the
+ contained files
+ on_error : "raise", "omit", "return"
+ If raise, an underlying exception will be raised (converted to KeyError
+ if the type is in self.missing_exceptions); if omit, keys with exception
+ will simply not be included in the output; if "return", all keys are
+ included in the output, but the value will be bytes or an exception
+ instance.
+ kwargs: passed to cat_file
+
+ Returns
+ -------
+ dict of {path: contents} if there are multiple paths
+ or the path has been otherwise expanded
+ """
+ paths = self.expand_path(path, recursive=recursive)
+ if (
+ len(paths) > 1
+ or isinstance(path, list)
+ or paths[0] != self._strip_protocol(path)
+ ):
+ out = {}
+ for path in paths:
+ try:
+ out[path] = self.cat_file(path, **kwargs)
+ except Exception as e:
+ if on_error == "raise":
+ raise
+ if on_error == "return":
+ out[path] = e
+ return out
+ else:
+ return self.cat_file(paths[0], **kwargs)
+
+ def get_file(self, rpath, lpath, callback=DEFAULT_CALLBACK, outfile=None, **kwargs):
+ """Copy single remote file to local"""
+ from .implementations.local import LocalFileSystem
+
+ if isfilelike(lpath):
+ outfile = lpath
+ elif self.isdir(rpath):
+ os.makedirs(lpath, exist_ok=True)
+ return None
+
+ fs = LocalFileSystem(auto_mkdir=True)
+ fs.makedirs(fs._parent(lpath), exist_ok=True)
+
+ with self.open(rpath, "rb", **kwargs) as f1:
+ if outfile is None:
+ outfile = open(lpath, "wb")
+
+ try:
+ callback.set_size(getattr(f1, "size", None))
+ data = True
+ while data:
+ data = f1.read(self.blocksize)
+ segment_len = outfile.write(data)
+ if segment_len is None:
+ segment_len = len(data)
+ callback.relative_update(segment_len)
+ finally:
+ if not isfilelike(lpath):
+ outfile.close()
+
+ def get(
+ self,
+ rpath,
+ lpath,
+ recursive=False,
+ callback=DEFAULT_CALLBACK,
+ maxdepth=None,
+ **kwargs,
+ ):
+ """Copy file(s) to local.
+
+ Copies a specific file or tree of files (if recursive=True). If lpath
+ ends with a "/", it will be assumed to be a directory, and target files
+ will go within. Can submit a list of paths, which may be glob-patterns
+ and will be expanded.
+
+ Calls get_file for each source.
+ """
+ if isinstance(lpath, list) and isinstance(rpath, list):
+ # No need to expand paths when both source and destination
+ # are provided as lists
+ rpaths = rpath
+ lpaths = lpath
+ else:
+ from .implementations.local import (
+ LocalFileSystem,
+ make_path_posix,
+ trailing_sep,
+ )
+
+ source_is_str = isinstance(rpath, str)
+ rpaths = self.expand_path(rpath, recursive=recursive, maxdepth=maxdepth)
+ if source_is_str and (not recursive or maxdepth is not None):
+ # Non-recursive glob does not copy directories
+ rpaths = [p for p in rpaths if not (trailing_sep(p) or self.isdir(p))]
+ if not rpaths:
+ return
+
+ if isinstance(lpath, str):
+ lpath = make_path_posix(lpath)
+
+ source_is_file = len(rpaths) == 1
+ dest_is_dir = isinstance(lpath, str) and (
+ trailing_sep(lpath) or LocalFileSystem().isdir(lpath)
+ )
+
+ exists = source_is_str and (
+ (has_magic(rpath) and source_is_file)
+ or (not has_magic(rpath) and dest_is_dir and not trailing_sep(rpath))
+ )
+ lpaths = other_paths(
+ rpaths,
+ lpath,
+ exists=exists,
+ flatten=not source_is_str,
+ )
+
+ callback.set_size(len(lpaths))
+ for lpath, rpath in callback.wrap(zip(lpaths, rpaths)):
+ with callback.branched(rpath, lpath) as child:
+ self.get_file(rpath, lpath, callback=child, **kwargs)
+
+ def put_file(self, lpath, rpath, callback=DEFAULT_CALLBACK, **kwargs):
+ """Copy single file to remote"""
+ if os.path.isdir(lpath):
+ self.makedirs(rpath, exist_ok=True)
+ return None
+
+ with open(lpath, "rb") as f1:
+ size = f1.seek(0, 2)
+ callback.set_size(size)
+ f1.seek(0)
+
+ self.mkdirs(self._parent(os.fspath(rpath)), exist_ok=True)
+ with self.open(rpath, "wb", **kwargs) as f2:
+ while f1.tell() < size:
+ data = f1.read(self.blocksize)
+ segment_len = f2.write(data)
+ if segment_len is None:
+ segment_len = len(data)
+ callback.relative_update(segment_len)
+
+ def put(
+ self,
+ lpath,
+ rpath,
+ recursive=False,
+ callback=DEFAULT_CALLBACK,
+ maxdepth=None,
+ **kwargs,
+ ):
+ """Copy file(s) from local.
+
+ Copies a specific file or tree of files (if recursive=True). If rpath
+ ends with a "/", it will be assumed to be a directory, and target files
+ will go within.
+
+ Calls put_file for each source.
+ """
+ if isinstance(lpath, list) and isinstance(rpath, list):
+ # No need to expand paths when both source and destination
+ # are provided as lists
+ rpaths = rpath
+ lpaths = lpath
+ else:
+ from .implementations.local import (
+ LocalFileSystem,
+ make_path_posix,
+ trailing_sep,
+ )
+
+ source_is_str = isinstance(lpath, str)
+ if source_is_str:
+ lpath = make_path_posix(lpath)
+ fs = LocalFileSystem()
+ lpaths = fs.expand_path(lpath, recursive=recursive, maxdepth=maxdepth)
+ if source_is_str and (not recursive or maxdepth is not None):
+ # Non-recursive glob does not copy directories
+ lpaths = [p for p in lpaths if not (trailing_sep(p) or fs.isdir(p))]
+ if not lpaths:
+ return
+
+ source_is_file = len(lpaths) == 1
+ dest_is_dir = isinstance(rpath, str) and (
+ trailing_sep(rpath) or self.isdir(rpath)
+ )
+
+ rpath = (
+ self._strip_protocol(rpath)
+ if isinstance(rpath, str)
+ else [self._strip_protocol(p) for p in rpath]
+ )
+ exists = source_is_str and (
+ (has_magic(lpath) and source_is_file)
+ or (not has_magic(lpath) and dest_is_dir and not trailing_sep(lpath))
+ )
+ rpaths = other_paths(
+ lpaths,
+ rpath,
+ exists=exists,
+ flatten=not source_is_str,
+ )
+
+ callback.set_size(len(rpaths))
+ for lpath, rpath in callback.wrap(zip(lpaths, rpaths)):
+ with callback.branched(lpath, rpath) as child:
+ self.put_file(lpath, rpath, callback=child, **kwargs)
+
+ def head(self, path, size=1024):
+ """Get the first ``size`` bytes from file"""
+ with self.open(path, "rb") as f:
+ return f.read(size)
+
+ def tail(self, path, size=1024):
+ """Get the last ``size`` bytes from file"""
+ with self.open(path, "rb") as f:
+ f.seek(max(-size, -f.size), 2)
+ return f.read()
+
+ def cp_file(self, path1, path2, **kwargs):
+ raise NotImplementedError
+
+ def copy(
+ self, path1, path2, recursive=False, maxdepth=None, on_error=None, **kwargs
+ ):
+ """Copy within two locations in the filesystem
+
+ on_error : "raise", "ignore"
+ If raise, any not-found exceptions will be raised; if ignore any
+ not-found exceptions will cause the path to be skipped; defaults to
+ raise unless recursive is true, where the default is ignore
+ """
+ if on_error is None and recursive:
+ on_error = "ignore"
+ elif on_error is None:
+ on_error = "raise"
+
+ if isinstance(path1, list) and isinstance(path2, list):
+ # No need to expand paths when both source and destination
+ # are provided as lists
+ paths1 = path1
+ paths2 = path2
+ else:
+ from .implementations.local import trailing_sep
+
+ source_is_str = isinstance(path1, str)
+ paths1 = self.expand_path(path1, recursive=recursive, maxdepth=maxdepth)
+ if source_is_str and (not recursive or maxdepth is not None):
+ # Non-recursive glob does not copy directories
+ paths1 = [p for p in paths1 if not (trailing_sep(p) or self.isdir(p))]
+ if not paths1:
+ return
+
+ source_is_file = len(paths1) == 1
+ dest_is_dir = isinstance(path2, str) and (
+ trailing_sep(path2) or self.isdir(path2)
+ )
+
+ exists = source_is_str and (
+ (has_magic(path1) and source_is_file)
+ or (not has_magic(path1) and dest_is_dir and not trailing_sep(path1))
+ )
+ paths2 = other_paths(
+ paths1,
+ path2,
+ exists=exists,
+ flatten=not source_is_str,
+ )
+
+ for p1, p2 in zip(paths1, paths2):
+ try:
+ self.cp_file(p1, p2, **kwargs)
+ except FileNotFoundError:
+ if on_error == "raise":
+ raise
+
+ def expand_path(self, path, recursive=False, maxdepth=None, **kwargs):
+ """Turn one or more globs or directories into a list of all matching paths
+ to files or directories.
+
+ kwargs are passed to ``glob`` or ``find``, which may in turn call ``ls``
+ """
+
+ if maxdepth is not None and maxdepth < 1:
+ raise ValueError("maxdepth must be at least 1")
+
+ if isinstance(path, (str, os.PathLike)):
+ out = self.expand_path([path], recursive, maxdepth)
+ else:
+ out = set()
+ path = [self._strip_protocol(p) for p in path]
+ for p in path:
+ if has_magic(p):
+ bit = set(self.glob(p, maxdepth=maxdepth, **kwargs))
+ out |= bit
+ if recursive:
+ # glob call above expanded one depth so if maxdepth is defined
+ # then decrement it in expand_path call below. If it is zero
+ # after decrementing then avoid expand_path call.
+ if maxdepth is not None and maxdepth <= 1:
+ continue
+ out |= set(
+ self.expand_path(
+ list(bit),
+ recursive=recursive,
+ maxdepth=maxdepth - 1 if maxdepth is not None else None,
+ **kwargs,
+ )
+ )
+ continue
+ elif recursive:
+ rec = set(
+ self.find(
+ p, maxdepth=maxdepth, withdirs=True, detail=False, **kwargs
+ )
+ )
+ out |= rec
+ if p not in out and (recursive is False or self.exists(p)):
+ # should only check once, for the root
+ out.add(p)
+ if not out:
+ raise FileNotFoundError(path)
+ return sorted(out)
+
+ def mv(self, path1, path2, recursive=False, maxdepth=None, **kwargs):
+ """Move file(s) from one location to another"""
+ if path1 == path2:
+ logger.debug("%s mv: The paths are the same, so no files were moved.", self)
+ else:
+ # explicitly raise exception to prevent data corruption
+ self.copy(
+ path1, path2, recursive=recursive, maxdepth=maxdepth, onerror="raise"
+ )
+ self.rm(path1, recursive=recursive)
+
+ def rm_file(self, path):
+ """Delete a file"""
+ self._rm(path)
+
+ def _rm(self, path):
+ """Delete one file"""
+ # this is the old name for the method, prefer rm_file
+ raise NotImplementedError
+
+ def rm(self, path, recursive=False, maxdepth=None):
+ """Delete files.
+
+ Parameters
+ ----------
+ path: str or list of str
+ File(s) to delete.
+ recursive: bool
+ If file(s) are directories, recursively delete contents and then
+ also remove the directory
+ maxdepth: int or None
+ Depth to pass to walk for finding files to delete, if recursive.
+ If None, there will be no limit and infinite recursion may be
+ possible.
+ """
+ path = self.expand_path(path, recursive=recursive, maxdepth=maxdepth)
+ for p in reversed(path):
+ self.rm_file(p)
+
+ @classmethod
+ def _parent(cls, path):
+ path = cls._strip_protocol(path)
+ if "/" in path:
+ parent = path.rsplit("/", 1)[0].lstrip(cls.root_marker)
+ return cls.root_marker + parent
+ else:
+ return cls.root_marker
+
+ def _open(
+ self,
+ path,
+ mode="rb",
+ block_size=None,
+ autocommit=True,
+ cache_options=None,
+ **kwargs,
+ ):
+ """Return raw bytes-mode file-like from the file-system"""
+ return AbstractBufferedFile(
+ self,
+ path,
+ mode,
+ block_size,
+ autocommit,
+ cache_options=cache_options,
+ **kwargs,
+ )
+
+ def open(
+ self,
+ path,
+ mode="rb",
+ block_size=None,
+ cache_options=None,
+ compression=None,
+ **kwargs,
+ ):
+ """
+ Return a file-like object from the filesystem
+
+ The resultant instance must function correctly in a context ``with``
+ block.
+
+ Parameters
+ ----------
+ path: str
+ Target file
+ mode: str like 'rb', 'w'
+ See builtin ``open()``
+ block_size: int
+ Some indication of buffering - this is a value in bytes
+ cache_options : dict, optional
+ Extra arguments to pass through to the cache.
+ compression: string or None
+ If given, open file using compression codec. Can either be a compression
+ name (a key in ``fsspec.compression.compr``) or "infer" to guess the
+ compression from the filename suffix.
+ encoding, errors, newline: passed on to TextIOWrapper for text mode
+ """
+ import io
+
+ path = self._strip_protocol(path)
+ if "b" not in mode:
+ mode = mode.replace("t", "") + "b"
+
+ text_kwargs = {
+ k: kwargs.pop(k)
+ for k in ["encoding", "errors", "newline"]
+ if k in kwargs
+ }
+ return io.TextIOWrapper(
+ self.open(
+ path,
+ mode,
+ block_size=block_size,
+ cache_options=cache_options,
+ compression=compression,
+ **kwargs,
+ ),
+ **text_kwargs,
+ )
+ else:
+ ac = kwargs.pop("autocommit", not self._intrans)
+ f = self._open(
+ path,
+ mode=mode,
+ block_size=block_size,
+ autocommit=ac,
+ cache_options=cache_options,
+ **kwargs,
+ )
+ if compression is not None:
+ from fsspec.compression import compr
+ from fsspec.core import get_compression
+
+ compression = get_compression(path, compression)
+ compress = compr[compression]
+ f = compress(f, mode=mode[0])
+
+ if not ac and "r" not in mode:
+ self.transaction.files.append(f)
+ return f
+
+ def touch(self, path, truncate=True, **kwargs):
+ """Create empty file, or update timestamp
+
+ Parameters
+ ----------
+ path: str
+ file location
+ truncate: bool
+ If True, always set file size to 0; if False, update timestamp and
+ leave file unchanged, if backend allows this
+ """
+ if truncate or not self.exists(path):
+ with self.open(path, "wb", **kwargs):
+ pass
+ else:
+ raise NotImplementedError # update timestamp, if possible
+
+ def ukey(self, path):
+ """Hash of file properties, to tell if it has changed"""
+ return sha256(str(self.info(path)).encode()).hexdigest()
+
+ def read_block(self, fn, offset, length, delimiter=None):
+ """Read a block of bytes from
+
+ Starting at ``offset`` of the file, read ``length`` bytes. If
+ ``delimiter`` is set then we ensure that the read starts and stops at
+ delimiter boundaries that follow the locations ``offset`` and ``offset
+ + length``. If ``offset`` is zero then we start at zero. The
+ bytestring returned WILL include the end delimiter string.
+
+ If offset+length is beyond the eof, reads to eof.
+
+ Parameters
+ ----------
+ fn: string
+ Path to filename
+ offset: int
+ Byte offset to start read
+ length: int
+ Number of bytes to read. If None, read to end.
+ delimiter: bytes (optional)
+ Ensure reading starts and stops at delimiter bytestring
+
+ Examples
+ --------
+ >>> fs.read_block('data/file.csv', 0, 13) # doctest: +SKIP
+ b'Alice, 100\\nBo'
+ >>> fs.read_block('data/file.csv', 0, 13, delimiter=b'\\n') # doctest: +SKIP
+ b'Alice, 100\\nBob, 200\\n'
+
+ Use ``length=None`` to read to the end of the file.
+ >>> fs.read_block('data/file.csv', 0, None, delimiter=b'\\n') # doctest: +SKIP
+ b'Alice, 100\\nBob, 200\\nCharlie, 300'
+
+ See Also
+ --------
+ :func:`fsspec.utils.read_block`
+ """
+ with self.open(fn, "rb") as f:
+ size = f.size
+ if length is None:
+ length = size
+ if size is not None and offset + length > size:
+ length = size - offset
+ return read_block(f, offset, length, delimiter)
+
+ def to_json(self, *, include_password: bool = True) -> str:
+ """
+ JSON representation of this filesystem instance.
+
+ Parameters
+ ----------
+ include_password: bool, default True
+ Whether to include the password (if any) in the output.
+
+ Returns
+ -------
+ JSON string with keys ``cls`` (the python location of this class),
+ protocol (text name of this class's protocol, first one in case of
+ multiple), ``args`` (positional args, usually empty), and all other
+ keyword arguments as their own keys.
+
+ Warnings
+ --------
+ Serialized filesystems may contain sensitive information which have been
+ passed to the constructor, such as passwords and tokens. Make sure you
+ store and send them in a secure environment!
+ """
+ from .json import FilesystemJSONEncoder
+
+ return json.dumps(
+ self,
+ cls=type(
+ "_FilesystemJSONEncoder",
+ (FilesystemJSONEncoder,),
+ {"include_password": include_password},
+ ),
+ )
+
+ @staticmethod
+ def from_json(blob: str) -> AbstractFileSystem:
+ """
+ Recreate a filesystem instance from JSON representation.
+
+ See ``.to_json()`` for the expected structure of the input.
+
+ Parameters
+ ----------
+ blob: str
+
+ Returns
+ -------
+ file system instance, not necessarily of this particular class.
+
+ Warnings
+ --------
+ This can import arbitrary modules (as determined by the ``cls`` key).
+ Make sure you haven't installed any modules that may execute malicious code
+ at import time.
+ """
+ from .json import FilesystemJSONDecoder
+
+ return json.loads(blob, cls=FilesystemJSONDecoder)
+
+ def to_dict(self, *, include_password: bool = True) -> Dict[str, Any]:
+ """
+ JSON-serializable dictionary representation of this filesystem instance.
+
+ Parameters
+ ----------
+ include_password: bool, default True
+ Whether to include the password (if any) in the output.
+
+ Returns
+ -------
+ Dictionary with keys ``cls`` (the python location of this class),
+ protocol (text name of this class's protocol, first one in case of
+ multiple), ``args`` (positional args, usually empty), and all other
+ keyword arguments as their own keys.
+
+ Warnings
+ --------
+ Serialized filesystems may contain sensitive information which have been
+ passed to the constructor, such as passwords and tokens. Make sure you
+ store and send them in a secure environment!
+ """
+ from .json import FilesystemJSONEncoder
+
+ json_encoder = FilesystemJSONEncoder()
+
+ cls = type(self)
+ proto = self.protocol
+
+ storage_options = dict(self.storage_options)
+ if not include_password:
+ storage_options.pop("password", None)
+
+ return dict(
+ cls=f"{cls.__module__}:{cls.__name__}",
+ protocol=proto[0] if isinstance(proto, (tuple, list)) else proto,
+ args=json_encoder.make_serializable(self.storage_args),
+ **json_encoder.make_serializable(storage_options),
+ )
+
+ @staticmethod
+ def from_dict(dct: Dict[str, Any]) -> AbstractFileSystem:
+ """
+ Recreate a filesystem instance from dictionary representation.
+
+ See ``.to_dict()`` for the expected structure of the input.
+
+ Parameters
+ ----------
+ dct: Dict[str, Any]
+
+ Returns
+ -------
+ file system instance, not necessarily of this particular class.
+
+ Warnings
+ --------
+ This can import arbitrary modules (as determined by the ``cls`` key).
+ Make sure you haven't installed any modules that may execute malicious code
+ at import time.
+ """
+ from .json import FilesystemJSONDecoder
+
+ json_decoder = FilesystemJSONDecoder()
+
+ dct = dict(dct) # Defensive copy
+
+ cls = FilesystemJSONDecoder.try_resolve_fs_cls(dct)
+ if cls is None:
+ raise ValueError("Not a serialized AbstractFileSystem")
+
+ dct.pop("cls", None)
+ dct.pop("protocol", None)
+
+ return cls(
+ *json_decoder.unmake_serializable(dct.pop("args", ())),
+ **json_decoder.unmake_serializable(dct),
+ )
+
+ def _get_pyarrow_filesystem(self):
+ """
+ Make a version of the FS instance which will be acceptable to pyarrow
+ """
+ # all instances already also derive from pyarrow
+ return self
+
+ def get_mapper(self, root="", check=False, create=False, missing_exceptions=None):
+ """Create key/value store based on this file-system
+
+ Makes a MutableMapping interface to the FS at the given root path.
+ See ``fsspec.mapping.FSMap`` for further details.
+ """
+ from .mapping import FSMap
+
+ return FSMap(
+ root,
+ self,
+ check=check,
+ create=create,
+ missing_exceptions=missing_exceptions,
+ )
+
+ @classmethod
+ def clear_instance_cache(cls):
+ """
+ Clear the cache of filesystem instances.
+
+ Notes
+ -----
+ Unless overridden by setting the ``cachable`` class attribute to False,
+ the filesystem class stores a reference to newly created instances. This
+ prevents Python's normal rules around garbage collection from working,
+ since the instances refcount will not drop to zero until
+ ``clear_instance_cache`` is called.
+ """
+ cls._cache.clear()
+
+ def created(self, path):
+ """Return the created timestamp of a file as a datetime.datetime"""
+ raise NotImplementedError
+
+ def modified(self, path):
+ """Return the modified timestamp of a file as a datetime.datetime"""
+ raise NotImplementedError
+
+ # ------------------------------------------------------------------------
+ # Aliases
+
+ def read_bytes(self, path, start=None, end=None, **kwargs):
+ """Alias of `AbstractFileSystem.cat_file`."""
+ return self.cat_file(path, start=start, end=end, **kwargs)
+
+ def write_bytes(self, path, value, **kwargs):
+ """Alias of `AbstractFileSystem.pipe_file`."""
+ self.pipe_file(path, value, **kwargs)
+
+ def makedir(self, path, create_parents=True, **kwargs):
+ """Alias of `AbstractFileSystem.mkdir`."""
+ return self.mkdir(path, create_parents=create_parents, **kwargs)
+
+ def mkdirs(self, path, exist_ok=False):
+ """Alias of `AbstractFileSystem.makedirs`."""
+ return self.makedirs(path, exist_ok=exist_ok)
+
+ def listdir(self, path, detail=True, **kwargs):
+ """Alias of `AbstractFileSystem.ls`."""
+ return self.ls(path, detail=detail, **kwargs)
+
+ def cp(self, path1, path2, **kwargs):
+ """Alias of `AbstractFileSystem.copy`."""
+ return self.copy(path1, path2, **kwargs)
+
+ def move(self, path1, path2, **kwargs):
+ """Alias of `AbstractFileSystem.mv`."""
+ return self.mv(path1, path2, **kwargs)
+
+ def stat(self, path, **kwargs):
+ """Alias of `AbstractFileSystem.info`."""
+ return self.info(path, **kwargs)
+
+ def disk_usage(self, path, total=True, maxdepth=None, **kwargs):
+ """Alias of `AbstractFileSystem.du`."""
+ return self.du(path, total=total, maxdepth=maxdepth, **kwargs)
+
+ def rename(self, path1, path2, **kwargs):
+ """Alias of `AbstractFileSystem.mv`."""
+ return self.mv(path1, path2, **kwargs)
+
+ def delete(self, path, recursive=False, maxdepth=None):
+ """Alias of `AbstractFileSystem.rm`."""
+ return self.rm(path, recursive=recursive, maxdepth=maxdepth)
+
+ def upload(self, lpath, rpath, recursive=False, **kwargs):
+ """Alias of `AbstractFileSystem.put`."""
+ return self.put(lpath, rpath, recursive=recursive, **kwargs)
+
+ def download(self, rpath, lpath, recursive=False, **kwargs):
+ """Alias of `AbstractFileSystem.get`."""
+ return self.get(rpath, lpath, recursive=recursive, **kwargs)
+
+ def sign(self, path, expiration=100, **kwargs):
+ """Create a signed URL representing the given path
+
+ Some implementations allow temporary URLs to be generated, as a
+ way of delegating credentials.
+
+ Parameters
+ ----------
+ path : str
+ The path on the filesystem
+ expiration : int
+ Number of seconds to enable the URL for (if supported)
+
+ Returns
+ -------
+ URL : str
+ The signed URL
+
+ Raises
+ ------
+ NotImplementedError : if method is not implemented for a filesystem
+ """
+ raise NotImplementedError("Sign is not implemented for this filesystem")
+
+ def _isfilestore(self):
+ # Originally inherited from pyarrow DaskFileSystem. Keeping this
+ # here for backwards compatibility as long as pyarrow uses its
+ # legacy fsspec-compatible filesystems and thus accepts fsspec
+ # filesystems as well
+ return False
+
+
+class AbstractBufferedFile(io.IOBase):
+ """Convenient class to derive from to provide buffering
+
+ In the case that the backend does not provide a pythonic file-like object
+ already, this class contains much of the logic to build one. The only
+ methods that need to be overridden are ``_upload_chunk``,
+ ``_initiate_upload`` and ``_fetch_range``.
+ """
+
+ DEFAULT_BLOCK_SIZE = 5 * 2**20
+ _details = None
+
+ def __init__(
+ self,
+ fs,
+ path,
+ mode="rb",
+ block_size="default",
+ autocommit=True,
+ cache_type="readahead",
+ cache_options=None,
+ size=None,
+ **kwargs,
+ ):
+ """
+ Template for files with buffered reading and writing
+
+ Parameters
+ ----------
+ fs: instance of FileSystem
+ path: str
+ location in file-system
+ mode: str
+ Normal file modes. Currently only 'wb', 'ab' or 'rb'. Some file
+ systems may be read-only, and some may not support append.
+ block_size: int
+ Buffer size for reading or writing, 'default' for class default
+ autocommit: bool
+ Whether to write to final destination; may only impact what
+ happens when file is being closed.
+ cache_type: {"readahead", "none", "mmap", "bytes"}, default "readahead"
+ Caching policy in read mode. See the definitions in ``core``.
+ cache_options : dict
+ Additional options passed to the constructor for the cache specified
+ by `cache_type`.
+ size: int
+ If given and in read mode, suppressed having to look up the file size
+ kwargs:
+ Gets stored as self.kwargs
+ """
+ from .core import caches
+
+ self.path = path
+ self.fs = fs
+ self.mode = mode
+ self.blocksize = (
+ self.DEFAULT_BLOCK_SIZE if block_size in ["default", None] else block_size
+ )
+ self.loc = 0
+ self.autocommit = autocommit
+ self.end = None
+ self.start = None
+ self.closed = False
+
+ if cache_options is None:
+ cache_options = {}
+
+ if "trim" in kwargs:
+ warnings.warn(
+ "Passing 'trim' to control the cache behavior has been deprecated. "
+ "Specify it within the 'cache_options' argument instead.",
+ FutureWarning,
+ )
+ cache_options["trim"] = kwargs.pop("trim")
+
+ self.kwargs = kwargs
+
+ if mode not in {"ab", "rb", "wb"}:
+ raise NotImplementedError("File mode not supported")
+ if mode == "rb":
+ if size is not None:
+ self.size = size
+ else:
+ self.size = self.details["size"]
+ self.cache = caches[cache_type](
+ self.blocksize, self._fetch_range, self.size, **cache_options
+ )
+ else:
+ self.buffer = io.BytesIO()
+ self.offset = None
+ self.forced = False
+ self.location = None
+
+ @property
+ def details(self):
+ if self._details is None:
+ self._details = self.fs.info(self.path)
+ return self._details
+
+ @details.setter
+ def details(self, value):
+ self._details = value
+ self.size = value["size"]
+
+ @property
+ def full_name(self):
+ return _unstrip_protocol(self.path, self.fs)
+
+ @property
+ def closed(self):
+ # get around this attr being read-only in IOBase
+ # use getattr here, since this can be called during del
+ return getattr(self, "_closed", True)
+
+ @closed.setter
+ def closed(self, c):
+ self._closed = c
+
+ def __hash__(self):
+ if "w" in self.mode:
+ return id(self)
+ else:
+ return int(tokenize(self.details), 16)
+
+ def __eq__(self, other):
+ """Files are equal if they have the same checksum, only in read mode"""
+ if self is other:
+ return True
+ return (
+ isinstance(other, type(self))
+ and self.mode == "rb"
+ and other.mode == "rb"
+ and hash(self) == hash(other)
+ )
+
+ def commit(self):
+ """Move from temp to final destination"""
+
+ def discard(self):
+ """Throw away temporary file"""
+
+ def info(self):
+ """File information about this path"""
+ if "r" in self.mode:
+ return self.details
+ else:
+ raise ValueError("Info not available while writing")
+
+ def tell(self):
+ """Current file location"""
+ return self.loc
+
+ def seek(self, loc, whence=0):
+ """Set current file location
+
+ Parameters
+ ----------
+ loc: int
+ byte location
+ whence: {0, 1, 2}
+ from start of file, current location or end of file, resp.
+ """
+ loc = int(loc)
+ if not self.mode == "rb":
+ raise OSError(ESPIPE, "Seek only available in read mode")
+ if whence == 0:
+ nloc = loc
+ elif whence == 1:
+ nloc = self.loc + loc
+ elif whence == 2:
+ nloc = self.size + loc
+ else:
+ raise ValueError(f"invalid whence ({whence}, should be 0, 1 or 2)")
+ if nloc < 0:
+ raise ValueError("Seek before start of file")
+ self.loc = nloc
+ return self.loc
+
+ def write(self, data):
+ """
+ Write data to buffer.
+
+ Buffer only sent on flush() or if buffer is greater than
+ or equal to blocksize.
+
+ Parameters
+ ----------
+ data: bytes
+ Set of bytes to be written.
+ """
+ if self.mode not in {"wb", "ab"}:
+ raise ValueError("File not in write mode")
+ if self.closed:
+ raise ValueError("I/O operation on closed file.")
+ if self.forced:
+ raise ValueError("This file has been force-flushed, can only close")
+ out = self.buffer.write(data)
+ self.loc += out
+ if self.buffer.tell() >= self.blocksize:
+ self.flush()
+ return out
+
+ def flush(self, force=False):
+ """
+ Write buffered data to backend store.
+
+ Writes the current buffer, if it is larger than the block-size, or if
+ the file is being closed.
+
+ Parameters
+ ----------
+ force: bool
+ When closing, write the last block even if it is smaller than
+ blocks are allowed to be. Disallows further writing to this file.
+ """
+
+ if self.closed:
+ raise ValueError("Flush on closed file")
+ if force and self.forced:
+ raise ValueError("Force flush cannot be called more than once")
+ if force:
+ self.forced = True
+
+ if self.mode not in {"wb", "ab"}:
+ # no-op to flush on read-mode
+ return
+
+ if not force and self.buffer.tell() < self.blocksize:
+ # Defer write on small block
+ return
+
+ if self.offset is None:
+ # Initialize a multipart upload
+ self.offset = 0
+ try:
+ self._initiate_upload()
+ except: # noqa: E722
+ self.closed = True
+ raise
+
+ if self._upload_chunk(final=force) is not False:
+ self.offset += self.buffer.seek(0, 2)
+ self.buffer = io.BytesIO()
+
+ def _upload_chunk(self, final=False):
+ """Write one part of a multi-block file upload
+
+ Parameters
+ ==========
+ final: bool
+ This is the last block, so should complete file, if
+ self.autocommit is True.
+ """
+ # may not yet have been initialized, may need to call _initialize_upload
+
+ def _initiate_upload(self):
+ """Create remote file/upload"""
+ pass
+
+ def _fetch_range(self, start, end):
+ """Get the specified set of bytes from remote"""
+ raise NotImplementedError
+
+ def read(self, length=-1):
+ """
+ Return data from cache, or fetch pieces as necessary
+
+ Parameters
+ ----------
+ length: int (-1)
+ Number of bytes to read; if <0, all remaining bytes.
+ """
+ length = -1 if length is None else int(length)
+ if self.mode != "rb":
+ raise ValueError("File not in read mode")
+ if length < 0:
+ length = self.size - self.loc
+ if self.closed:
+ raise ValueError("I/O operation on closed file.")
+ if length == 0:
+ # don't even bother calling fetch
+ return b""
+ out = self.cache._fetch(self.loc, self.loc + length)
+
+ logger.debug(
+ "%s read: %i - %i %s",
+ self,
+ self.loc,
+ self.loc + length,
+ self.cache._log_stats(),
+ )
+ self.loc += len(out)
+ return out
+
+ def readinto(self, b):
+ """mirrors builtin file's readinto method
+
+ https://docs.python.org/3/library/io.html#io.RawIOBase.readinto
+ """
+ out = memoryview(b).cast("B")
+ data = self.read(out.nbytes)
+ out[: len(data)] = data
+ return len(data)
+
+ def readuntil(self, char=b"\n", blocks=None):
+ """Return data between current position and first occurrence of char
+
+ char is included in the output, except if the end of the tile is
+ encountered first.
+
+ Parameters
+ ----------
+ char: bytes
+ Thing to find
+ blocks: None or int
+ How much to read in each go. Defaults to file blocksize - which may
+ mean a new read on every call.
+ """
+ out = []
+ while True:
+ start = self.tell()
+ part = self.read(blocks or self.blocksize)
+ if len(part) == 0:
+ break
+ found = part.find(char)
+ if found > -1:
+ out.append(part[: found + len(char)])
+ self.seek(start + found + len(char))
+ break
+ out.append(part)
+ return b"".join(out)
+
+ def readline(self):
+ """Read until first occurrence of newline character
+
+ Note that, because of character encoding, this is not necessarily a
+ true line ending.
+ """
+ return self.readuntil(b"\n")
+
+ def __next__(self):
+ out = self.readline()
+ if out:
+ return out
+ raise StopIteration
+
+ def __iter__(self):
+ return self
+
+ def readlines(self):
+ """Return all data, split by the newline character"""
+ data = self.read()
+ lines = data.split(b"\n")
+ out = [l + b"\n" for l in lines[:-1]]
+ if data.endswith(b"\n"):
+ return out
+ else:
+ return out + [lines[-1]]
+ # return list(self) ???
+
+ def readinto1(self, b):
+ return self.readinto(b)
+
+ def close(self):
+ """Close file
+
+ Finalizes writes, discards cache
+ """
+ if getattr(self, "_unclosable", False):
+ return
+ if self.closed:
+ return
+ if self.mode == "rb":
+ self.cache = None
+ else:
+ if not self.forced:
+ self.flush(force=True)
+
+ if self.fs is not None:
+ self.fs.invalidate_cache(self.path)
+ self.fs.invalidate_cache(self.fs._parent(self.path))
+
+ self.closed = True
+
+ def readable(self):
+ """Whether opened for reading"""
+ return self.mode == "rb" and not self.closed
+
+ def seekable(self):
+ """Whether is seekable (only in read mode)"""
+ return self.readable()
+
+ def writable(self):
+ """Whether opened for writing"""
+ return self.mode in {"wb", "ab"} and not self.closed
+
+ def __del__(self):
+ if not self.closed:
+ self.close()
+
+ def __str__(self):
+ return f""
+
+ __repr__ = __str__
+
+ def __enter__(self):
+ return self
+
+ def __exit__(self, *args):
+ self.close()
diff --git a/parrot/lib/python3.10/site-packages/fsspec/transaction.py b/parrot/lib/python3.10/site-packages/fsspec/transaction.py
new file mode 100644
index 0000000000000000000000000000000000000000..77293f63ecc5f611e19d849ef236d53e9c258efc
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/fsspec/transaction.py
@@ -0,0 +1,90 @@
+from collections import deque
+
+
+class Transaction:
+ """Filesystem transaction write context
+
+ Gathers files for deferred commit or discard, so that several write
+ operations can be finalized semi-atomically. This works by having this
+ instance as the ``.transaction`` attribute of the given filesystem
+ """
+
+ def __init__(self, fs, **kwargs):
+ """
+ Parameters
+ ----------
+ fs: FileSystem instance
+ """
+ self.fs = fs
+ self.files = deque()
+
+ def __enter__(self):
+ self.start()
+ return self
+
+ def __exit__(self, exc_type, exc_val, exc_tb):
+ """End transaction and commit, if exit is not due to exception"""
+ # only commit if there was no exception
+ self.complete(commit=exc_type is None)
+ if self.fs:
+ self.fs._intrans = False
+ self.fs._transaction = None
+ self.fs = None
+
+ def start(self):
+ """Start a transaction on this FileSystem"""
+ self.files = deque() # clean up after previous failed completions
+ self.fs._intrans = True
+
+ def complete(self, commit=True):
+ """Finish transaction: commit or discard all deferred files"""
+ while self.files:
+ f = self.files.popleft()
+ if commit:
+ f.commit()
+ else:
+ f.discard()
+ self.fs._intrans = False
+ self.fs._transaction = None
+ self.fs = None
+
+
+class FileActor:
+ def __init__(self):
+ self.files = []
+
+ def commit(self):
+ for f in self.files:
+ f.commit()
+ self.files.clear()
+
+ def discard(self):
+ for f in self.files:
+ f.discard()
+ self.files.clear()
+
+ def append(self, f):
+ self.files.append(f)
+
+
+class DaskTransaction(Transaction):
+ def __init__(self, fs):
+ """
+ Parameters
+ ----------
+ fs: FileSystem instance
+ """
+ import distributed
+
+ super().__init__(fs)
+ client = distributed.default_client()
+ self.files = client.submit(FileActor, actor=True).result()
+
+ def complete(self, commit=True):
+ """Finish transaction: commit or discard all deferred files"""
+ if commit:
+ self.files.commit().result()
+ else:
+ self.files.discard().result()
+ self.fs._intrans = False
+ self.fs = None
diff --git a/parrot/lib/python3.10/site-packages/fsspec/utils.py b/parrot/lib/python3.10/site-packages/fsspec/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..703d55f4e38db48dbca078a1093183747907c972
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/fsspec/utils.py
@@ -0,0 +1,740 @@
+from __future__ import annotations
+
+import contextlib
+import logging
+import math
+import os
+import pathlib
+import re
+import sys
+import tempfile
+from functools import partial
+from hashlib import md5
+from importlib.metadata import version
+from typing import (
+ IO,
+ TYPE_CHECKING,
+ Any,
+ Callable,
+ Iterable,
+ Iterator,
+ Sequence,
+ TypeVar,
+)
+from urllib.parse import urlsplit
+
+if TYPE_CHECKING:
+ from typing_extensions import TypeGuard
+
+ from fsspec.spec import AbstractFileSystem
+
+
+DEFAULT_BLOCK_SIZE = 5 * 2**20
+
+T = TypeVar("T")
+
+
+def infer_storage_options(
+ urlpath: str, inherit_storage_options: dict[str, Any] | None = None
+) -> dict[str, Any]:
+ """Infer storage options from URL path and merge it with existing storage
+ options.
+
+ Parameters
+ ----------
+ urlpath: str or unicode
+ Either local absolute file path or URL (hdfs://namenode:8020/file.csv)
+ inherit_storage_options: dict (optional)
+ Its contents will get merged with the inferred information from the
+ given path
+
+ Returns
+ -------
+ Storage options dict.
+
+ Examples
+ --------
+ >>> infer_storage_options('/mnt/datasets/test.csv') # doctest: +SKIP
+ {"protocol": "file", "path", "/mnt/datasets/test.csv"}
+ >>> infer_storage_options(
+ ... 'hdfs://username:pwd@node:123/mnt/datasets/test.csv?q=1',
+ ... inherit_storage_options={'extra': 'value'},
+ ... ) # doctest: +SKIP
+ {"protocol": "hdfs", "username": "username", "password": "pwd",
+ "host": "node", "port": 123, "path": "/mnt/datasets/test.csv",
+ "url_query": "q=1", "extra": "value"}
+ """
+ # Handle Windows paths including disk name in this special case
+ if (
+ re.match(r"^[a-zA-Z]:[\\/]", urlpath)
+ or re.match(r"^[a-zA-Z0-9]+://", urlpath) is None
+ ):
+ return {"protocol": "file", "path": urlpath}
+
+ parsed_path = urlsplit(urlpath)
+ protocol = parsed_path.scheme or "file"
+ if parsed_path.fragment:
+ path = "#".join([parsed_path.path, parsed_path.fragment])
+ else:
+ path = parsed_path.path
+ if protocol == "file":
+ # Special case parsing file protocol URL on Windows according to:
+ # https://msdn.microsoft.com/en-us/library/jj710207.aspx
+ windows_path = re.match(r"^/([a-zA-Z])[:|]([\\/].*)$", path)
+ if windows_path:
+ path = "%s:%s" % windows_path.groups()
+
+ if protocol in ["http", "https"]:
+ # for HTTP, we don't want to parse, as requests will anyway
+ return {"protocol": protocol, "path": urlpath}
+
+ options: dict[str, Any] = {"protocol": protocol, "path": path}
+
+ if parsed_path.netloc:
+ # Parse `hostname` from netloc manually because `parsed_path.hostname`
+ # lowercases the hostname which is not always desirable (e.g. in S3):
+ # https://github.com/dask/dask/issues/1417
+ options["host"] = parsed_path.netloc.rsplit("@", 1)[-1].rsplit(":", 1)[0]
+
+ if protocol in ("s3", "s3a", "gcs", "gs"):
+ options["path"] = options["host"] + options["path"]
+ else:
+ options["host"] = options["host"]
+ if parsed_path.port:
+ options["port"] = parsed_path.port
+ if parsed_path.username:
+ options["username"] = parsed_path.username
+ if parsed_path.password:
+ options["password"] = parsed_path.password
+
+ if parsed_path.query:
+ options["url_query"] = parsed_path.query
+ if parsed_path.fragment:
+ options["url_fragment"] = parsed_path.fragment
+
+ if inherit_storage_options:
+ update_storage_options(options, inherit_storage_options)
+
+ return options
+
+
+def update_storage_options(
+ options: dict[str, Any], inherited: dict[str, Any] | None = None
+) -> None:
+ if not inherited:
+ inherited = {}
+ collisions = set(options) & set(inherited)
+ if collisions:
+ for collision in collisions:
+ if options.get(collision) != inherited.get(collision):
+ raise KeyError(
+ f"Collision between inferred and specified storage "
+ f"option:\n{collision}"
+ )
+ options.update(inherited)
+
+
+# Compression extensions registered via fsspec.compression.register_compression
+compressions: dict[str, str] = {}
+
+
+def infer_compression(filename: str) -> str | None:
+ """Infer compression, if available, from filename.
+
+ Infer a named compression type, if registered and available, from filename
+ extension. This includes builtin (gz, bz2, zip) compressions, as well as
+ optional compressions. See fsspec.compression.register_compression.
+ """
+ extension = os.path.splitext(filename)[-1].strip(".").lower()
+ if extension in compressions:
+ return compressions[extension]
+ return None
+
+
+def build_name_function(max_int: float) -> Callable[[int], str]:
+ """Returns a function that receives a single integer
+ and returns it as a string padded by enough zero characters
+ to align with maximum possible integer
+
+ >>> name_f = build_name_function(57)
+
+ >>> name_f(7)
+ '07'
+ >>> name_f(31)
+ '31'
+ >>> build_name_function(1000)(42)
+ '0042'
+ >>> build_name_function(999)(42)
+ '042'
+ >>> build_name_function(0)(0)
+ '0'
+ """
+ # handle corner cases max_int is 0 or exact power of 10
+ max_int += 1e-8
+
+ pad_length = int(math.ceil(math.log10(max_int)))
+
+ def name_function(i: int) -> str:
+ return str(i).zfill(pad_length)
+
+ return name_function
+
+
+def seek_delimiter(file: IO[bytes], delimiter: bytes, blocksize: int) -> bool:
+ r"""Seek current file to file start, file end, or byte after delimiter seq.
+
+ Seeks file to next chunk delimiter, where chunks are defined on file start,
+ a delimiting sequence, and file end. Use file.tell() to see location afterwards.
+ Note that file start is a valid split, so must be at offset > 0 to seek for
+ delimiter.
+
+ Parameters
+ ----------
+ file: a file
+ delimiter: bytes
+ a delimiter like ``b'\n'`` or message sentinel, matching file .read() type
+ blocksize: int
+ Number of bytes to read from the file at once.
+
+
+ Returns
+ -------
+ Returns True if a delimiter was found, False if at file start or end.
+
+ """
+
+ if file.tell() == 0:
+ # beginning-of-file, return without seek
+ return False
+
+ # Interface is for binary IO, with delimiter as bytes, but initialize last
+ # with result of file.read to preserve compatibility with text IO.
+ last: bytes | None = None
+ while True:
+ current = file.read(blocksize)
+ if not current:
+ # end-of-file without delimiter
+ return False
+ full = last + current if last else current
+ try:
+ if delimiter in full:
+ i = full.index(delimiter)
+ file.seek(file.tell() - (len(full) - i) + len(delimiter))
+ return True
+ elif len(current) < blocksize:
+ # end-of-file without delimiter
+ return False
+ except (OSError, ValueError):
+ pass
+ last = full[-len(delimiter) :]
+
+
+def read_block(
+ f: IO[bytes],
+ offset: int,
+ length: int | None,
+ delimiter: bytes | None = None,
+ split_before: bool = False,
+) -> bytes:
+ """Read a block of bytes from a file
+
+ Parameters
+ ----------
+ f: File
+ Open file
+ offset: int
+ Byte offset to start read
+ length: int
+ Number of bytes to read, read through end of file if None
+ delimiter: bytes (optional)
+ Ensure reading starts and stops at delimiter bytestring
+ split_before: bool (optional)
+ Start/stop read *before* delimiter bytestring.
+
+
+ If using the ``delimiter=`` keyword argument we ensure that the read
+ starts and stops at delimiter boundaries that follow the locations
+ ``offset`` and ``offset + length``. If ``offset`` is zero then we
+ start at zero, regardless of delimiter. The bytestring returned WILL
+ include the terminating delimiter string.
+
+ Examples
+ --------
+
+ >>> from io import BytesIO # doctest: +SKIP
+ >>> f = BytesIO(b'Alice, 100\\nBob, 200\\nCharlie, 300') # doctest: +SKIP
+ >>> read_block(f, 0, 13) # doctest: +SKIP
+ b'Alice, 100\\nBo'
+
+ >>> read_block(f, 0, 13, delimiter=b'\\n') # doctest: +SKIP
+ b'Alice, 100\\nBob, 200\\n'
+
+ >>> read_block(f, 10, 10, delimiter=b'\\n') # doctest: +SKIP
+ b'Bob, 200\\nCharlie, 300'
+ """
+ if delimiter:
+ f.seek(offset)
+ found_start_delim = seek_delimiter(f, delimiter, 2**16)
+ if length is None:
+ return f.read()
+ start = f.tell()
+ length -= start - offset
+
+ f.seek(start + length)
+ found_end_delim = seek_delimiter(f, delimiter, 2**16)
+ end = f.tell()
+
+ # Adjust split location to before delimiter if seek found the
+ # delimiter sequence, not start or end of file.
+ if found_start_delim and split_before:
+ start -= len(delimiter)
+
+ if found_end_delim and split_before:
+ end -= len(delimiter)
+
+ offset = start
+ length = end - start
+
+ f.seek(offset)
+
+ # TODO: allow length to be None and read to the end of the file?
+ assert length is not None
+ b = f.read(length)
+ return b
+
+
+def tokenize(*args: Any, **kwargs: Any) -> str:
+ """Deterministic token
+
+ (modified from dask.base)
+
+ >>> tokenize([1, 2, '3'])
+ '9d71491b50023b06fc76928e6eddb952'
+
+ >>> tokenize('Hello') == tokenize('Hello')
+ True
+ """
+ if kwargs:
+ args += (kwargs,)
+ try:
+ h = md5(str(args).encode())
+ except ValueError:
+ # FIPS systems: https://github.com/fsspec/filesystem_spec/issues/380
+ h = md5(str(args).encode(), usedforsecurity=False)
+ return h.hexdigest()
+
+
+def stringify_path(filepath: str | os.PathLike[str] | pathlib.Path) -> str:
+ """Attempt to convert a path-like object to a string.
+
+ Parameters
+ ----------
+ filepath: object to be converted
+
+ Returns
+ -------
+ filepath_str: maybe a string version of the object
+
+ Notes
+ -----
+ Objects supporting the fspath protocol are coerced according to its
+ __fspath__ method.
+
+ For backwards compatibility with older Python version, pathlib.Path
+ objects are specially coerced.
+
+ Any other object is passed through unchanged, which includes bytes,
+ strings, buffers, or anything else that's not even path-like.
+ """
+ if isinstance(filepath, str):
+ return filepath
+ elif hasattr(filepath, "__fspath__"):
+ return filepath.__fspath__()
+ elif hasattr(filepath, "path"):
+ return filepath.path
+ else:
+ return filepath # type: ignore[return-value]
+
+
+def make_instance(
+ cls: Callable[..., T], args: Sequence[Any], kwargs: dict[str, Any]
+) -> T:
+ inst = cls(*args, **kwargs)
+ inst._determine_worker() # type: ignore[attr-defined]
+ return inst
+
+
+def common_prefix(paths: Iterable[str]) -> str:
+ """For a list of paths, find the shortest prefix common to all"""
+ parts = [p.split("/") for p in paths]
+ lmax = min(len(p) for p in parts)
+ end = 0
+ for i in range(lmax):
+ end = all(p[i] == parts[0][i] for p in parts)
+ if not end:
+ break
+ i += end
+ return "/".join(parts[0][:i])
+
+
+def other_paths(
+ paths: list[str],
+ path2: str | list[str],
+ exists: bool = False,
+ flatten: bool = False,
+) -> list[str]:
+ """In bulk file operations, construct a new file tree from a list of files
+
+ Parameters
+ ----------
+ paths: list of str
+ The input file tree
+ path2: str or list of str
+ Root to construct the new list in. If this is already a list of str, we just
+ assert it has the right number of elements.
+ exists: bool (optional)
+ For a str destination, it is already exists (and is a dir), files should
+ end up inside.
+ flatten: bool (optional)
+ Whether to flatten the input directory tree structure so that the output files
+ are in the same directory.
+
+ Returns
+ -------
+ list of str
+ """
+
+ if isinstance(path2, str):
+ path2 = path2.rstrip("/")
+
+ if flatten:
+ path2 = ["/".join((path2, p.split("/")[-1])) for p in paths]
+ else:
+ cp = common_prefix(paths)
+ if exists:
+ cp = cp.rsplit("/", 1)[0]
+ if not cp and all(not s.startswith("/") for s in paths):
+ path2 = ["/".join([path2, p]) for p in paths]
+ else:
+ path2 = [p.replace(cp, path2, 1) for p in paths]
+ else:
+ assert len(paths) == len(path2)
+ return path2
+
+
+def is_exception(obj: Any) -> bool:
+ return isinstance(obj, BaseException)
+
+
+def isfilelike(f: Any) -> TypeGuard[IO[bytes]]:
+ for attr in ["read", "close", "tell"]:
+ if not hasattr(f, attr):
+ return False
+ return True
+
+
+def get_protocol(url: str) -> str:
+ url = stringify_path(url)
+ parts = re.split(r"(\:\:|\://)", url, maxsplit=1)
+ if len(parts) > 1:
+ return parts[0]
+ return "file"
+
+
+def can_be_local(path: str) -> bool:
+ """Can the given URL be used with open_local?"""
+ from fsspec import get_filesystem_class
+
+ try:
+ return getattr(get_filesystem_class(get_protocol(path)), "local_file", False)
+ except (ValueError, ImportError):
+ # not in registry or import failed
+ return False
+
+
+def get_package_version_without_import(name: str) -> str | None:
+ """For given package name, try to find the version without importing it
+
+ Import and package.__version__ is still the backup here, so an import
+ *might* happen.
+
+ Returns either the version string, or None if the package
+ or the version was not readily found.
+ """
+ if name in sys.modules:
+ mod = sys.modules[name]
+ if hasattr(mod, "__version__"):
+ return mod.__version__
+ try:
+ return version(name)
+ except: # noqa: E722
+ pass
+ try:
+ import importlib
+
+ mod = importlib.import_module(name)
+ return mod.__version__
+ except (ImportError, AttributeError):
+ return None
+
+
+def setup_logging(
+ logger: logging.Logger | None = None,
+ logger_name: str | None = None,
+ level: str = "DEBUG",
+ clear: bool = True,
+) -> logging.Logger:
+ if logger is None and logger_name is None:
+ raise ValueError("Provide either logger object or logger name")
+ logger = logger or logging.getLogger(logger_name)
+ handle = logging.StreamHandler()
+ formatter = logging.Formatter(
+ "%(asctime)s - %(name)s - %(levelname)s - %(funcName)s -- %(message)s"
+ )
+ handle.setFormatter(formatter)
+ if clear:
+ logger.handlers.clear()
+ logger.addHandler(handle)
+ logger.setLevel(level)
+ return logger
+
+
+def _unstrip_protocol(name: str, fs: AbstractFileSystem) -> str:
+ return fs.unstrip_protocol(name)
+
+
+def mirror_from(
+ origin_name: str, methods: Iterable[str]
+) -> Callable[[type[T]], type[T]]:
+ """Mirror attributes and methods from the given
+ origin_name attribute of the instance to the
+ decorated class"""
+
+ def origin_getter(method: str, self: Any) -> Any:
+ origin = getattr(self, origin_name)
+ return getattr(origin, method)
+
+ def wrapper(cls: type[T]) -> type[T]:
+ for method in methods:
+ wrapped_method = partial(origin_getter, method)
+ setattr(cls, method, property(wrapped_method))
+ return cls
+
+ return wrapper
+
+
+@contextlib.contextmanager
+def nullcontext(obj: T) -> Iterator[T]:
+ yield obj
+
+
+def merge_offset_ranges(
+ paths: list[str],
+ starts: list[int] | int,
+ ends: list[int] | int,
+ max_gap: int = 0,
+ max_block: int | None = None,
+ sort: bool = True,
+) -> tuple[list[str], list[int], list[int]]:
+ """Merge adjacent byte-offset ranges when the inter-range
+ gap is <= `max_gap`, and when the merged byte range does not
+ exceed `max_block` (if specified). By default, this function
+ will re-order the input paths and byte ranges to ensure sorted
+ order. If the user can guarantee that the inputs are already
+ sorted, passing `sort=False` will skip the re-ordering.
+ """
+ # Check input
+ if not isinstance(paths, list):
+ raise TypeError
+ if not isinstance(starts, list):
+ starts = [starts] * len(paths)
+ if not isinstance(ends, list):
+ ends = [ends] * len(paths)
+ if len(starts) != len(paths) or len(ends) != len(paths):
+ raise ValueError
+
+ # Early Return
+ if len(starts) <= 1:
+ return paths, starts, ends
+
+ starts = [s or 0 for s in starts]
+ # Sort by paths and then ranges if `sort=True`
+ if sort:
+ paths, starts, ends = (
+ list(v)
+ for v in zip(
+ *sorted(
+ zip(paths, starts, ends),
+ )
+ )
+ )
+
+ if paths:
+ # Loop through the coupled `paths`, `starts`, and
+ # `ends`, and merge adjacent blocks when appropriate
+ new_paths = paths[:1]
+ new_starts = starts[:1]
+ new_ends = ends[:1]
+ for i in range(1, len(paths)):
+ if paths[i] == paths[i - 1] and new_ends[-1] is None:
+ continue
+ elif (
+ paths[i] != paths[i - 1]
+ or ((starts[i] - new_ends[-1]) > max_gap)
+ or (max_block is not None and (ends[i] - new_starts[-1]) > max_block)
+ ):
+ # Cannot merge with previous block.
+ # Add new `paths`, `starts`, and `ends` elements
+ new_paths.append(paths[i])
+ new_starts.append(starts[i])
+ new_ends.append(ends[i])
+ else:
+ # Merge with previous block by updating the
+ # last element of `ends`
+ new_ends[-1] = ends[i]
+ return new_paths, new_starts, new_ends
+
+ # `paths` is empty. Just return input lists
+ return paths, starts, ends
+
+
+def file_size(filelike: IO[bytes]) -> int:
+ """Find length of any open read-mode file-like"""
+ pos = filelike.tell()
+ try:
+ return filelike.seek(0, 2)
+ finally:
+ filelike.seek(pos)
+
+
+@contextlib.contextmanager
+def atomic_write(path: str, mode: str = "wb"):
+ """
+ A context manager that opens a temporary file next to `path` and, on exit,
+ replaces `path` with the temporary file, thereby updating `path`
+ atomically.
+ """
+ fd, fn = tempfile.mkstemp(
+ dir=os.path.dirname(path), prefix=os.path.basename(path) + "-"
+ )
+ try:
+ with open(fd, mode) as fp:
+ yield fp
+ except BaseException:
+ with contextlib.suppress(FileNotFoundError):
+ os.unlink(fn)
+ raise
+ else:
+ os.replace(fn, path)
+
+
+def _translate(pat, STAR, QUESTION_MARK):
+ # Copied from: https://github.com/python/cpython/pull/106703.
+ res: list[str] = []
+ add = res.append
+ i, n = 0, len(pat)
+ while i < n:
+ c = pat[i]
+ i = i + 1
+ if c == "*":
+ # compress consecutive `*` into one
+ if (not res) or res[-1] is not STAR:
+ add(STAR)
+ elif c == "?":
+ add(QUESTION_MARK)
+ elif c == "[":
+ j = i
+ if j < n and pat[j] == "!":
+ j = j + 1
+ if j < n and pat[j] == "]":
+ j = j + 1
+ while j < n and pat[j] != "]":
+ j = j + 1
+ if j >= n:
+ add("\\[")
+ else:
+ stuff = pat[i:j]
+ if "-" not in stuff:
+ stuff = stuff.replace("\\", r"\\")
+ else:
+ chunks = []
+ k = i + 2 if pat[i] == "!" else i + 1
+ while True:
+ k = pat.find("-", k, j)
+ if k < 0:
+ break
+ chunks.append(pat[i:k])
+ i = k + 1
+ k = k + 3
+ chunk = pat[i:j]
+ if chunk:
+ chunks.append(chunk)
+ else:
+ chunks[-1] += "-"
+ # Remove empty ranges -- invalid in RE.
+ for k in range(len(chunks) - 1, 0, -1):
+ if chunks[k - 1][-1] > chunks[k][0]:
+ chunks[k - 1] = chunks[k - 1][:-1] + chunks[k][1:]
+ del chunks[k]
+ # Escape backslashes and hyphens for set difference (--).
+ # Hyphens that create ranges shouldn't be escaped.
+ stuff = "-".join(
+ s.replace("\\", r"\\").replace("-", r"\-") for s in chunks
+ )
+ # Escape set operations (&&, ~~ and ||).
+ stuff = re.sub(r"([&~|])", r"\\\1", stuff)
+ i = j + 1
+ if not stuff:
+ # Empty range: never match.
+ add("(?!)")
+ elif stuff == "!":
+ # Negated empty range: match any character.
+ add(".")
+ else:
+ if stuff[0] == "!":
+ stuff = "^" + stuff[1:]
+ elif stuff[0] in ("^", "["):
+ stuff = "\\" + stuff
+ add(f"[{stuff}]")
+ else:
+ add(re.escape(c))
+ assert i == n
+ return res
+
+
+def glob_translate(pat):
+ # Copied from: https://github.com/python/cpython/pull/106703.
+ # The keyword parameters' values are fixed to:
+ # recursive=True, include_hidden=True, seps=None
+ """Translate a pathname with shell wildcards to a regular expression."""
+ if os.path.altsep:
+ seps = os.path.sep + os.path.altsep
+ else:
+ seps = os.path.sep
+ escaped_seps = "".join(map(re.escape, seps))
+ any_sep = f"[{escaped_seps}]" if len(seps) > 1 else escaped_seps
+ not_sep = f"[^{escaped_seps}]"
+ one_last_segment = f"{not_sep}+"
+ one_segment = f"{one_last_segment}{any_sep}"
+ any_segments = f"(?:.+{any_sep})?"
+ any_last_segments = ".*"
+ results = []
+ parts = re.split(any_sep, pat)
+ last_part_idx = len(parts) - 1
+ for idx, part in enumerate(parts):
+ if part == "*":
+ results.append(one_segment if idx < last_part_idx else one_last_segment)
+ continue
+ if part == "**":
+ results.append(any_segments if idx < last_part_idx else any_last_segments)
+ continue
+ elif "**" in part:
+ raise ValueError(
+ "Invalid pattern: '**' can only be an entire path component"
+ )
+ if part:
+ results.extend(_translate(part, f"{not_sep}*", not_sep))
+ if idx < last_part_idx:
+ results.append(any_sep)
+ res = "".join(results)
+ return rf"(?s:{res})\Z"
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/__init__.cpython-310.pyc b/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a515211ecd80b5df4ce4351b2a0bdd35b843ac7e
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/__init__.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/_commit_api.cpython-310.pyc b/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/_commit_api.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dba2f8956003919319bf2d2f6ce4fd622c5dd059
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/_commit_api.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/_inference_endpoints.cpython-310.pyc b/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/_inference_endpoints.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d2daefc77d2a63fff162498e79135c14b0d93d89
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/_inference_endpoints.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/_login.cpython-310.pyc b/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/_login.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8dda00ce726149d23141e9cf8ef702503cb91149
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/_login.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/_snapshot_download.cpython-310.pyc b/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/_snapshot_download.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c390f8870614e576f820e90c32968a47f0662991
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/_snapshot_download.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/_space_api.cpython-310.pyc b/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/_space_api.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ea44316cceda3f5244d94fe1c5e2c968f972559b
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/_space_api.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/_upload_large_folder.cpython-310.pyc b/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/_upload_large_folder.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3dd0d5eeb1fb58d5f8792ccf8ed804d2407252b2
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/_upload_large_folder.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/_webhooks_payload.cpython-310.pyc b/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/_webhooks_payload.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..530da4bc15dbb8fa6f77b18df438711fc0ec634c
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/_webhooks_payload.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/community.cpython-310.pyc b/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/community.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..53f04c6904aa55e5c5d347417784d2053aa54679
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/community.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/errors.cpython-310.pyc b/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/errors.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d863519f19c4478598ab06e3fa5f6328435473e7
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/errors.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/fastai_utils.cpython-310.pyc b/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/fastai_utils.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..50a0e22721f0003a2e3c6eddcc2871e0e0815d3b
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/fastai_utils.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/hub_mixin.cpython-310.pyc b/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/hub_mixin.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1e0a4ffeecfeb0aa1bed7c5c7375385b9233be88
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/hub_mixin.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/lfs.cpython-310.pyc b/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/lfs.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..900557ec770f4a945880c4a71c1d1c8685221a85
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/lfs.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/repocard.cpython-310.pyc b/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/repocard.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8b2cd8ce67c3d6a35dd0e7349bfa7f3578ed3f7c
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/repocard.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/repocard_data.cpython-310.pyc b/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/repocard_data.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..398e71c28cd4e352dcaf97df5961da2139e4db8c
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/repocard_data.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/repository.cpython-310.pyc b/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/repository.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0366e155f4265aaff3ece1998628731dcf35ee19
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/huggingface_hub/__pycache__/repository.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/commands/__init__.py b/parrot/lib/python3.10/site-packages/huggingface_hub/commands/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..49d088214505b9604964ab142e7f8a5b38ccd5ef
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/huggingface_hub/commands/__init__.py
@@ -0,0 +1,27 @@
+# Copyright 2020 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from abc import ABC, abstractmethod
+from argparse import _SubParsersAction
+
+
+class BaseHuggingfaceCLICommand(ABC):
+ @staticmethod
+ @abstractmethod
+ def register_subcommand(parser: _SubParsersAction):
+ raise NotImplementedError()
+
+ @abstractmethod
+ def run(self):
+ raise NotImplementedError()
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/commands/__pycache__/_cli_utils.cpython-310.pyc b/parrot/lib/python3.10/site-packages/huggingface_hub/commands/__pycache__/_cli_utils.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..42fad724f8c804d2095504e764f2e24b47f5ee3a
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/huggingface_hub/commands/__pycache__/_cli_utils.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/commands/__pycache__/huggingface_cli.cpython-310.pyc b/parrot/lib/python3.10/site-packages/huggingface_hub/commands/__pycache__/huggingface_cli.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f141ad0752b8929071b821da2c09a85b27cd8394
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/huggingface_hub/commands/__pycache__/huggingface_cli.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/commands/download.py b/parrot/lib/python3.10/site-packages/huggingface_hub/commands/download.py
new file mode 100644
index 0000000000000000000000000000000000000000..10e22c3d1eb83dbb52c4a633fb66f19b3f35d8e7
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/huggingface_hub/commands/download.py
@@ -0,0 +1,200 @@
+# coding=utf-8
+# Copyright 2023-present, the HuggingFace Inc. team.
+#
+# 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.
+"""Contains command to download files from the Hub with the CLI.
+
+Usage:
+ huggingface-cli download --help
+
+ # Download file
+ huggingface-cli download gpt2 config.json
+
+ # Download entire repo
+ huggingface-cli download fffiloni/zeroscope --repo-type=space --revision=refs/pr/78
+
+ # Download repo with filters
+ huggingface-cli download gpt2 --include="*.safetensors"
+
+ # Download with token
+ huggingface-cli download Wauplin/private-model --token=hf_***
+
+ # Download quietly (no progress bar, no warnings, only the returned path)
+ huggingface-cli download gpt2 config.json --quiet
+
+ # Download to local dir
+ huggingface-cli download gpt2 --local-dir=./models/gpt2
+"""
+
+import warnings
+from argparse import Namespace, _SubParsersAction
+from typing import List, Optional
+
+from huggingface_hub import logging
+from huggingface_hub._snapshot_download import snapshot_download
+from huggingface_hub.commands import BaseHuggingfaceCLICommand
+from huggingface_hub.file_download import hf_hub_download
+from huggingface_hub.utils import disable_progress_bars, enable_progress_bars
+
+
+logger = logging.get_logger(__name__)
+
+
+class DownloadCommand(BaseHuggingfaceCLICommand):
+ @staticmethod
+ def register_subcommand(parser: _SubParsersAction):
+ download_parser = parser.add_parser("download", help="Download files from the Hub")
+ download_parser.add_argument(
+ "repo_id", type=str, help="ID of the repo to download from (e.g. `username/repo-name`)."
+ )
+ download_parser.add_argument(
+ "filenames", type=str, nargs="*", help="Files to download (e.g. `config.json`, `data/metadata.jsonl`)."
+ )
+ download_parser.add_argument(
+ "--repo-type",
+ choices=["model", "dataset", "space"],
+ default="model",
+ help="Type of repo to download from (defaults to 'model').",
+ )
+ download_parser.add_argument(
+ "--revision",
+ type=str,
+ help="An optional Git revision id which can be a branch name, a tag, or a commit hash.",
+ )
+ download_parser.add_argument(
+ "--include", nargs="*", type=str, help="Glob patterns to match files to download."
+ )
+ download_parser.add_argument(
+ "--exclude", nargs="*", type=str, help="Glob patterns to exclude from files to download."
+ )
+ download_parser.add_argument(
+ "--cache-dir", type=str, help="Path to the directory where to save the downloaded files."
+ )
+ download_parser.add_argument(
+ "--local-dir",
+ type=str,
+ help=(
+ "If set, the downloaded file will be placed under this directory. Check out"
+ " https://huggingface.co/docs/huggingface_hub/guides/download#download-files-to-local-folder for more"
+ " details."
+ ),
+ )
+ download_parser.add_argument(
+ "--local-dir-use-symlinks",
+ choices=["auto", "True", "False"],
+ help=("Deprecated and ignored. Downloading to a local directory does not use symlinks anymore."),
+ )
+ download_parser.add_argument(
+ "--force-download",
+ action="store_true",
+ help="If True, the files will be downloaded even if they are already cached.",
+ )
+ download_parser.add_argument(
+ "--resume-download",
+ action="store_true",
+ help="Deprecated and ignored. Downloading a file to local dir always attempts to resume previously interrupted downloads (unless hf-transfer is enabled).",
+ )
+ download_parser.add_argument(
+ "--token", type=str, help="A User Access Token generated from https://huggingface.co/settings/tokens"
+ )
+ download_parser.add_argument(
+ "--quiet",
+ action="store_true",
+ help="If True, progress bars are disabled and only the path to the download files is printed.",
+ )
+ download_parser.add_argument(
+ "--max-workers",
+ type=int,
+ default=8,
+ help="Maximum number of workers to use for downloading files. Default is 8.",
+ )
+ download_parser.set_defaults(func=DownloadCommand)
+
+ def __init__(self, args: Namespace) -> None:
+ self.token = args.token
+ self.repo_id: str = args.repo_id
+ self.filenames: List[str] = args.filenames
+ self.repo_type: str = args.repo_type
+ self.revision: Optional[str] = args.revision
+ self.include: Optional[List[str]] = args.include
+ self.exclude: Optional[List[str]] = args.exclude
+ self.cache_dir: Optional[str] = args.cache_dir
+ self.local_dir: Optional[str] = args.local_dir
+ self.force_download: bool = args.force_download
+ self.resume_download: Optional[bool] = args.resume_download or None
+ self.quiet: bool = args.quiet
+ self.max_workers: int = args.max_workers
+
+ if args.local_dir_use_symlinks is not None:
+ warnings.warn(
+ "Ignoring --local-dir-use-symlinks. Downloading to a local directory does not use symlinks anymore.",
+ FutureWarning,
+ )
+
+ def run(self) -> None:
+ if self.quiet:
+ disable_progress_bars()
+ with warnings.catch_warnings():
+ warnings.simplefilter("ignore")
+ print(self._download()) # Print path to downloaded files
+ enable_progress_bars()
+ else:
+ logging.set_verbosity_info()
+ print(self._download()) # Print path to downloaded files
+ logging.set_verbosity_warning()
+
+ def _download(self) -> str:
+ # Warn user if patterns are ignored
+ if len(self.filenames) > 0:
+ if self.include is not None and len(self.include) > 0:
+ warnings.warn("Ignoring `--include` since filenames have being explicitly set.")
+ if self.exclude is not None and len(self.exclude) > 0:
+ warnings.warn("Ignoring `--exclude` since filenames have being explicitly set.")
+
+ # Single file to download: use `hf_hub_download`
+ if len(self.filenames) == 1:
+ return hf_hub_download(
+ repo_id=self.repo_id,
+ repo_type=self.repo_type,
+ revision=self.revision,
+ filename=self.filenames[0],
+ cache_dir=self.cache_dir,
+ resume_download=self.resume_download,
+ force_download=self.force_download,
+ token=self.token,
+ local_dir=self.local_dir,
+ library_name="huggingface-cli",
+ )
+
+ # Otherwise: use `snapshot_download` to ensure all files comes from same revision
+ elif len(self.filenames) == 0:
+ allow_patterns = self.include
+ ignore_patterns = self.exclude
+ else:
+ allow_patterns = self.filenames
+ ignore_patterns = None
+
+ return snapshot_download(
+ repo_id=self.repo_id,
+ repo_type=self.repo_type,
+ revision=self.revision,
+ allow_patterns=allow_patterns,
+ ignore_patterns=ignore_patterns,
+ resume_download=self.resume_download,
+ force_download=self.force_download,
+ cache_dir=self.cache_dir,
+ token=self.token,
+ local_dir=self.local_dir,
+ library_name="huggingface-cli",
+ max_workers=self.max_workers,
+ )
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/commands/env.py b/parrot/lib/python3.10/site-packages/huggingface_hub/commands/env.py
new file mode 100644
index 0000000000000000000000000000000000000000..23f2828bbfebda0a633b4b3c6883432e4a534c79
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/huggingface_hub/commands/env.py
@@ -0,0 +1,36 @@
+# Copyright 2022 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains command to print information about the environment.
+
+Usage:
+ huggingface-cli env
+"""
+
+from argparse import _SubParsersAction
+
+from ..utils import dump_environment_info
+from . import BaseHuggingfaceCLICommand
+
+
+class EnvironmentCommand(BaseHuggingfaceCLICommand):
+ def __init__(self, args):
+ self.args = args
+
+ @staticmethod
+ def register_subcommand(parser: _SubParsersAction):
+ env_parser = parser.add_parser("env", help="Print information about the environment.")
+ env_parser.set_defaults(func=EnvironmentCommand)
+
+ def run(self) -> None:
+ dump_environment_info()
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/commands/huggingface_cli.py b/parrot/lib/python3.10/site-packages/huggingface_hub/commands/huggingface_cli.py
new file mode 100644
index 0000000000000000000000000000000000000000..1e790b5eb1b40710072ef5fc2597b9e6c3325355
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/huggingface_hub/commands/huggingface_cli.py
@@ -0,0 +1,61 @@
+# Copyright 2020 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from argparse import ArgumentParser
+
+from huggingface_hub.commands.delete_cache import DeleteCacheCommand
+from huggingface_hub.commands.download import DownloadCommand
+from huggingface_hub.commands.env import EnvironmentCommand
+from huggingface_hub.commands.lfs import LfsCommands
+from huggingface_hub.commands.repo_files import RepoFilesCommand
+from huggingface_hub.commands.scan_cache import ScanCacheCommand
+from huggingface_hub.commands.tag import TagCommands
+from huggingface_hub.commands.upload import UploadCommand
+from huggingface_hub.commands.upload_large_folder import UploadLargeFolderCommand
+from huggingface_hub.commands.user import UserCommands
+from huggingface_hub.commands.version import VersionCommand
+
+
+def main():
+ parser = ArgumentParser("huggingface-cli", usage="huggingface-cli []")
+ commands_parser = parser.add_subparsers(help="huggingface-cli command helpers")
+
+ # Register commands
+ DownloadCommand.register_subcommand(commands_parser)
+ UploadCommand.register_subcommand(commands_parser)
+ RepoFilesCommand.register_subcommand(commands_parser)
+ EnvironmentCommand.register_subcommand(commands_parser)
+ UserCommands.register_subcommand(commands_parser)
+ LfsCommands.register_subcommand(commands_parser)
+ ScanCacheCommand.register_subcommand(commands_parser)
+ DeleteCacheCommand.register_subcommand(commands_parser)
+ TagCommands.register_subcommand(commands_parser)
+ VersionCommand.register_subcommand(commands_parser)
+
+ # Experimental
+ UploadLargeFolderCommand.register_subcommand(commands_parser)
+
+ # Let's go
+ args = parser.parse_args()
+ if not hasattr(args, "func"):
+ parser.print_help()
+ exit(1)
+
+ # Run
+ service = args.func(args)
+ service.run()
+
+
+if __name__ == "__main__":
+ main()
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/commands/scan_cache.py b/parrot/lib/python3.10/site-packages/huggingface_hub/commands/scan_cache.py
new file mode 100644
index 0000000000000000000000000000000000000000..799b9ba5523134a668aa0171e9f3668694299341
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/huggingface_hub/commands/scan_cache.py
@@ -0,0 +1,181 @@
+# coding=utf-8
+# Copyright 2022-present, the HuggingFace Inc. team.
+#
+# 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.
+"""Contains command to scan the HF cache directory.
+
+Usage:
+ huggingface-cli scan-cache
+ huggingface-cli scan-cache -v
+ huggingface-cli scan-cache -vvv
+ huggingface-cli scan-cache --dir ~/.cache/huggingface/hub
+"""
+
+import time
+from argparse import Namespace, _SubParsersAction
+from typing import Optional
+
+from ..utils import CacheNotFound, HFCacheInfo, scan_cache_dir
+from . import BaseHuggingfaceCLICommand
+from ._cli_utils import ANSI, tabulate
+
+
+class ScanCacheCommand(BaseHuggingfaceCLICommand):
+ @staticmethod
+ def register_subcommand(parser: _SubParsersAction):
+ scan_cache_parser = parser.add_parser("scan-cache", help="Scan cache directory.")
+
+ scan_cache_parser.add_argument(
+ "--dir",
+ type=str,
+ default=None,
+ help="cache directory to scan (optional). Default to the default HuggingFace cache.",
+ )
+ scan_cache_parser.add_argument(
+ "-v",
+ "--verbose",
+ action="count",
+ default=0,
+ help="show a more verbose output",
+ )
+ scan_cache_parser.set_defaults(func=ScanCacheCommand)
+
+ def __init__(self, args: Namespace) -> None:
+ self.verbosity: int = args.verbose
+ self.cache_dir: Optional[str] = args.dir
+
+ def run(self):
+ try:
+ t0 = time.time()
+ hf_cache_info = scan_cache_dir(self.cache_dir)
+ t1 = time.time()
+ except CacheNotFound as exc:
+ cache_dir = exc.cache_dir
+ print(f"Cache directory not found: {cache_dir}")
+ return
+
+ self._print_hf_cache_info_as_table(hf_cache_info)
+
+ print(
+ f"\nDone in {round(t1 - t0, 1)}s. Scanned {len(hf_cache_info.repos)} repo(s)"
+ f" for a total of {ANSI.red(hf_cache_info.size_on_disk_str)}."
+ )
+ if len(hf_cache_info.warnings) > 0:
+ message = f"Got {len(hf_cache_info.warnings)} warning(s) while scanning."
+ if self.verbosity >= 3:
+ print(ANSI.gray(message))
+ for warning in hf_cache_info.warnings:
+ print(ANSI.gray(warning))
+ else:
+ print(ANSI.gray(message + " Use -vvv to print details."))
+
+ def _print_hf_cache_info_as_table(self, hf_cache_info: HFCacheInfo) -> None:
+ print(get_table(hf_cache_info, verbosity=self.verbosity))
+
+
+def get_table(hf_cache_info: HFCacheInfo, *, verbosity: int = 0) -> str:
+ """Generate a table from the [`HFCacheInfo`] object.
+
+ Pass `verbosity=0` to get a table with a single row per repo, with columns
+ "repo_id", "repo_type", "size_on_disk", "nb_files", "last_accessed", "last_modified", "refs", "local_path".
+
+ Pass `verbosity=1` to get a table with a row per repo and revision (thus multiple rows can appear for a single repo), with columns
+ "repo_id", "repo_type", "revision", "size_on_disk", "nb_files", "last_modified", "refs", "local_path".
+
+ Example:
+ ```py
+ >>> from huggingface_hub.utils import scan_cache_dir
+ >>> from huggingface_hub.commands.scan_cache import get_table
+
+ >>> hf_cache_info = scan_cache_dir()
+ HFCacheInfo(...)
+
+ >>> print(get_table(hf_cache_info, verbosity=0))
+ REPO ID REPO TYPE SIZE ON DISK NB FILES LAST_ACCESSED LAST_MODIFIED REFS LOCAL PATH
+ --------------------------------------------------- --------- ------------ -------- ------------- ------------- ---- --------------------------------------------------------------------------------------------------
+ roberta-base model 2.7M 5 1 day ago 1 week ago main C:\\Users\\admin\\.cache\\huggingface\\hub\\models--roberta-base
+ suno/bark model 8.8K 1 1 week ago 1 week ago main C:\\Users\\admin\\.cache\\huggingface\\hub\\models--suno--bark
+ t5-base model 893.8M 4 4 days ago 7 months ago main C:\\Users\\admin\\.cache\\huggingface\\hub\\models--t5-base
+ t5-large model 3.0G 4 5 weeks ago 5 months ago main C:\\Users\\admin\\.cache\\huggingface\\hub\\models--t5-large
+
+ >>> print(get_table(hf_cache_info, verbosity=1))
+ REPO ID REPO TYPE REVISION SIZE ON DISK NB FILES LAST_MODIFIED REFS LOCAL PATH
+ --------------------------------------------------- --------- ---------------------------------------- ------------ -------- ------------- ---- -----------------------------------------------------------------------------------------------------------------------------------------------------
+ roberta-base model e2da8e2f811d1448a5b465c236feacd80ffbac7b 2.7M 5 1 week ago main C:\\Users\\admin\\.cache\\huggingface\\hub\\models--roberta-base\\snapshots\\e2da8e2f811d1448a5b465c236feacd80ffbac7b
+ suno/bark model 70a8a7d34168586dc5d028fa9666aceade177992 8.8K 1 1 week ago main C:\\Users\\admin\\.cache\\huggingface\\hub\\models--suno--bark\\snapshots\\70a8a7d34168586dc5d028fa9666aceade177992
+ t5-base model a9723ea7f1b39c1eae772870f3b547bf6ef7e6c1 893.8M 4 7 months ago main C:\\Users\\admin\\.cache\\huggingface\\hub\\models--t5-base\\snapshots\\a9723ea7f1b39c1eae772870f3b547bf6ef7e6c1
+ t5-large model 150ebc2c4b72291e770f58e6057481c8d2ed331a 3.0G 4 5 months ago main C:\\Users\\admin\\.cache\\huggingface\\hub\\models--t5-large\\snapshots\\150ebc2c4b72291e770f58e6057481c8d2ed331a ```
+ ```
+
+ Args:
+ hf_cache_info ([`HFCacheInfo`]):
+ The HFCacheInfo object to print.
+ verbosity (`int`, *optional*):
+ The verbosity level. Defaults to 0.
+
+ Returns:
+ `str`: The table as a string.
+ """
+ if verbosity == 0:
+ return tabulate(
+ rows=[
+ [
+ repo.repo_id,
+ repo.repo_type,
+ "{:>12}".format(repo.size_on_disk_str),
+ repo.nb_files,
+ repo.last_accessed_str,
+ repo.last_modified_str,
+ ", ".join(sorted(repo.refs)),
+ str(repo.repo_path),
+ ]
+ for repo in sorted(hf_cache_info.repos, key=lambda repo: repo.repo_path)
+ ],
+ headers=[
+ "REPO ID",
+ "REPO TYPE",
+ "SIZE ON DISK",
+ "NB FILES",
+ "LAST_ACCESSED",
+ "LAST_MODIFIED",
+ "REFS",
+ "LOCAL PATH",
+ ],
+ )
+ else:
+ return tabulate(
+ rows=[
+ [
+ repo.repo_id,
+ repo.repo_type,
+ revision.commit_hash,
+ "{:>12}".format(revision.size_on_disk_str),
+ revision.nb_files,
+ revision.last_modified_str,
+ ", ".join(sorted(revision.refs)),
+ str(revision.snapshot_path),
+ ]
+ for repo in sorted(hf_cache_info.repos, key=lambda repo: repo.repo_path)
+ for revision in sorted(repo.revisions, key=lambda revision: revision.commit_hash)
+ ],
+ headers=[
+ "REPO ID",
+ "REPO TYPE",
+ "REVISION",
+ "SIZE ON DISK",
+ "NB FILES",
+ "LAST_MODIFIED",
+ "REFS",
+ "LOCAL PATH",
+ ],
+ )
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/commands/upload.py b/parrot/lib/python3.10/site-packages/huggingface_hub/commands/upload.py
new file mode 100644
index 0000000000000000000000000000000000000000..c5db1118e3cc562c2d09b06b11611bbaee6d53c2
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/huggingface_hub/commands/upload.py
@@ -0,0 +1,299 @@
+# coding=utf-8
+# Copyright 2023-present, the HuggingFace Inc. team.
+#
+# 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.
+"""Contains command to upload a repo or file with the CLI.
+
+Usage:
+ # Upload file (implicit)
+ huggingface-cli upload my-cool-model ./my-cool-model.safetensors
+
+ # Upload file (explicit)
+ huggingface-cli upload my-cool-model ./my-cool-model.safetensors model.safetensors
+
+ # Upload directory (implicit). If `my-cool-model/` is a directory it will be uploaded, otherwise an exception is raised.
+ huggingface-cli upload my-cool-model
+
+ # Upload directory (explicit)
+ huggingface-cli upload my-cool-model ./models/my-cool-model .
+
+ # Upload filtered directory (example: tensorboard logs except for the last run)
+ huggingface-cli upload my-cool-model ./model/training /logs --include "*.tfevents.*" --exclude "*20230905*"
+
+ # Upload private dataset
+ huggingface-cli upload Wauplin/my-cool-dataset ./data . --repo-type=dataset --private
+
+ # Upload with token
+ huggingface-cli upload Wauplin/my-cool-model --token=hf_****
+
+ # Sync local Space with Hub (upload new files, delete removed files)
+ huggingface-cli upload Wauplin/space-example --repo-type=space --exclude="/logs/*" --delete="*" --commit-message="Sync local Space with Hub"
+
+ # Schedule commits every 30 minutes
+ huggingface-cli upload Wauplin/my-cool-model --every=30
+"""
+
+import os
+import time
+import warnings
+from argparse import Namespace, _SubParsersAction
+from typing import List, Optional
+
+from huggingface_hub import logging
+from huggingface_hub._commit_scheduler import CommitScheduler
+from huggingface_hub.commands import BaseHuggingfaceCLICommand
+from huggingface_hub.constants import HF_HUB_ENABLE_HF_TRANSFER
+from huggingface_hub.errors import RevisionNotFoundError
+from huggingface_hub.hf_api import HfApi
+from huggingface_hub.utils import disable_progress_bars, enable_progress_bars
+
+
+logger = logging.get_logger(__name__)
+
+
+class UploadCommand(BaseHuggingfaceCLICommand):
+ @staticmethod
+ def register_subcommand(parser: _SubParsersAction):
+ upload_parser = parser.add_parser("upload", help="Upload a file or a folder to a repo on the Hub")
+ upload_parser.add_argument(
+ "repo_id", type=str, help="The ID of the repo to upload to (e.g. `username/repo-name`)."
+ )
+ upload_parser.add_argument(
+ "local_path", nargs="?", help="Local path to the file or folder to upload. Defaults to current directory."
+ )
+ upload_parser.add_argument(
+ "path_in_repo",
+ nargs="?",
+ help="Path of the file or folder in the repo. Defaults to the relative path of the file or folder.",
+ )
+ upload_parser.add_argument(
+ "--repo-type",
+ choices=["model", "dataset", "space"],
+ default="model",
+ help="Type of the repo to upload to (e.g. `dataset`).",
+ )
+ upload_parser.add_argument(
+ "--revision",
+ type=str,
+ help=(
+ "An optional Git revision to push to. It can be a branch name or a PR reference. If revision does not"
+ " exist and `--create-pr` is not set, a branch will be automatically created."
+ ),
+ )
+ upload_parser.add_argument(
+ "--private",
+ action="store_true",
+ help=(
+ "Whether to create a private repo if repo doesn't exist on the Hub. Ignored if the repo already"
+ " exists."
+ ),
+ )
+ upload_parser.add_argument("--include", nargs="*", type=str, help="Glob patterns to match files to upload.")
+ upload_parser.add_argument(
+ "--exclude", nargs="*", type=str, help="Glob patterns to exclude from files to upload."
+ )
+ upload_parser.add_argument(
+ "--delete",
+ nargs="*",
+ type=str,
+ help="Glob patterns for file to be deleted from the repo while committing.",
+ )
+ upload_parser.add_argument(
+ "--commit-message", type=str, help="The summary / title / first line of the generated commit."
+ )
+ upload_parser.add_argument("--commit-description", type=str, help="The description of the generated commit.")
+ upload_parser.add_argument(
+ "--create-pr", action="store_true", help="Whether to upload content as a new Pull Request."
+ )
+ upload_parser.add_argument(
+ "--every",
+ type=float,
+ help="If set, a background job is scheduled to create commits every `every` minutes.",
+ )
+ upload_parser.add_argument(
+ "--token", type=str, help="A User Access Token generated from https://huggingface.co/settings/tokens"
+ )
+ upload_parser.add_argument(
+ "--quiet",
+ action="store_true",
+ help="If True, progress bars are disabled and only the path to the uploaded files is printed.",
+ )
+ upload_parser.set_defaults(func=UploadCommand)
+
+ def __init__(self, args: Namespace) -> None:
+ self.repo_id: str = args.repo_id
+ self.repo_type: Optional[str] = args.repo_type
+ self.revision: Optional[str] = args.revision
+ self.private: bool = args.private
+
+ self.include: Optional[List[str]] = args.include
+ self.exclude: Optional[List[str]] = args.exclude
+ self.delete: Optional[List[str]] = args.delete
+
+ self.commit_message: Optional[str] = args.commit_message
+ self.commit_description: Optional[str] = args.commit_description
+ self.create_pr: bool = args.create_pr
+ self.api: HfApi = HfApi(token=args.token, library_name="huggingface-cli")
+ self.quiet: bool = args.quiet # disable warnings and progress bars
+
+ # Check `--every` is valid
+ if args.every is not None and args.every <= 0:
+ raise ValueError(f"`every` must be a positive value (got '{args.every}')")
+ self.every: Optional[float] = args.every
+
+ # Resolve `local_path` and `path_in_repo`
+ repo_name: str = args.repo_id.split("/")[-1] # e.g. "Wauplin/my-cool-model" => "my-cool-model"
+ self.local_path: str
+ self.path_in_repo: str
+ if args.local_path is None and os.path.isfile(repo_name):
+ # Implicit case 1: user provided only a repo_id which happen to be a local file as well => upload it with same name
+ self.local_path = repo_name
+ self.path_in_repo = repo_name
+ elif args.local_path is None and os.path.isdir(repo_name):
+ # Implicit case 2: user provided only a repo_id which happen to be a local folder as well => upload it at root
+ self.local_path = repo_name
+ self.path_in_repo = "."
+ elif args.local_path is None:
+ # Implicit case 3: user provided only a repo_id that does not match a local file or folder
+ # => the user must explicitly provide a local_path => raise exception
+ raise ValueError(f"'{repo_name}' is not a local file or folder. Please set `local_path` explicitly.")
+ elif args.path_in_repo is None and os.path.isfile(args.local_path):
+ # Explicit local path to file, no path in repo => upload it at root with same name
+ self.local_path = args.local_path
+ self.path_in_repo = os.path.basename(args.local_path)
+ elif args.path_in_repo is None:
+ # Explicit local path to folder, no path in repo => upload at root
+ self.local_path = args.local_path
+ self.path_in_repo = "."
+ else:
+ # Finally, if both paths are explicit
+ self.local_path = args.local_path
+ self.path_in_repo = args.path_in_repo
+
+ def run(self) -> None:
+ if self.quiet:
+ disable_progress_bars()
+ with warnings.catch_warnings():
+ warnings.simplefilter("ignore")
+ print(self._upload())
+ enable_progress_bars()
+ else:
+ logging.set_verbosity_info()
+ print(self._upload())
+ logging.set_verbosity_warning()
+
+ def _upload(self) -> str:
+ if os.path.isfile(self.local_path):
+ if self.include is not None and len(self.include) > 0:
+ warnings.warn("Ignoring `--include` since a single file is uploaded.")
+ if self.exclude is not None and len(self.exclude) > 0:
+ warnings.warn("Ignoring `--exclude` since a single file is uploaded.")
+ if self.delete is not None and len(self.delete) > 0:
+ warnings.warn("Ignoring `--delete` since a single file is uploaded.")
+
+ if not HF_HUB_ENABLE_HF_TRANSFER:
+ logger.info(
+ "Consider using `hf_transfer` for faster uploads. This solution comes with some limitations. See"
+ " https://huggingface.co/docs/huggingface_hub/hf_transfer for more details."
+ )
+
+ # Schedule commits if `every` is set
+ if self.every is not None:
+ if os.path.isfile(self.local_path):
+ # If file => watch entire folder + use allow_patterns
+ folder_path = os.path.dirname(self.local_path)
+ path_in_repo = (
+ self.path_in_repo[: -len(self.local_path)] # remove filename from path_in_repo
+ if self.path_in_repo.endswith(self.local_path)
+ else self.path_in_repo
+ )
+ allow_patterns = [self.local_path]
+ ignore_patterns = []
+ else:
+ folder_path = self.local_path
+ path_in_repo = self.path_in_repo
+ allow_patterns = self.include or []
+ ignore_patterns = self.exclude or []
+ if self.delete is not None and len(self.delete) > 0:
+ warnings.warn("Ignoring `--delete` when uploading with scheduled commits.")
+
+ scheduler = CommitScheduler(
+ folder_path=folder_path,
+ repo_id=self.repo_id,
+ repo_type=self.repo_type,
+ revision=self.revision,
+ allow_patterns=allow_patterns,
+ ignore_patterns=ignore_patterns,
+ path_in_repo=path_in_repo,
+ private=self.private,
+ every=self.every,
+ hf_api=self.api,
+ )
+ print(f"Scheduling commits every {self.every} minutes to {scheduler.repo_id}.")
+ try: # Block main thread until KeyboardInterrupt
+ while True:
+ time.sleep(100)
+ except KeyboardInterrupt:
+ scheduler.stop()
+ return "Stopped scheduled commits."
+
+ # Otherwise, create repo and proceed with the upload
+ if not os.path.isfile(self.local_path) and not os.path.isdir(self.local_path):
+ raise FileNotFoundError(f"No such file or directory: '{self.local_path}'.")
+ repo_id = self.api.create_repo(
+ repo_id=self.repo_id,
+ repo_type=self.repo_type,
+ exist_ok=True,
+ private=self.private,
+ space_sdk="gradio" if self.repo_type == "space" else None,
+ # ^ We don't want it to fail when uploading to a Space => let's set Gradio by default.
+ # ^ I'd rather not add CLI args to set it explicitly as we already have `huggingface-cli repo create` for that.
+ ).repo_id
+
+ # Check if branch already exists and if not, create it
+ if self.revision is not None and not self.create_pr:
+ try:
+ self.api.repo_info(repo_id=repo_id, repo_type=self.repo_type, revision=self.revision)
+ except RevisionNotFoundError:
+ logger.info(f"Branch '{self.revision}' not found. Creating it...")
+ self.api.create_branch(repo_id=repo_id, repo_type=self.repo_type, branch=self.revision, exist_ok=True)
+ # ^ `exist_ok=True` to avoid race concurrency issues
+
+ # File-based upload
+ if os.path.isfile(self.local_path):
+ return self.api.upload_file(
+ path_or_fileobj=self.local_path,
+ path_in_repo=self.path_in_repo,
+ repo_id=repo_id,
+ repo_type=self.repo_type,
+ revision=self.revision,
+ commit_message=self.commit_message,
+ commit_description=self.commit_description,
+ create_pr=self.create_pr,
+ )
+
+ # Folder-based upload
+ else:
+ return self.api.upload_folder(
+ folder_path=self.local_path,
+ path_in_repo=self.path_in_repo,
+ repo_id=repo_id,
+ repo_type=self.repo_type,
+ revision=self.revision,
+ commit_message=self.commit_message,
+ commit_description=self.commit_description,
+ create_pr=self.create_pr,
+ allow_patterns=self.include,
+ ignore_patterns=self.exclude,
+ delete_patterns=self.delete,
+ )
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/commands/upload_large_folder.py b/parrot/lib/python3.10/site-packages/huggingface_hub/commands/upload_large_folder.py
new file mode 100644
index 0000000000000000000000000000000000000000..61c12a9f62f8e12591d8db4c9defc50dd91db705
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/huggingface_hub/commands/upload_large_folder.py
@@ -0,0 +1,129 @@
+# coding=utf-8
+# Copyright 2023-present, the HuggingFace Inc. team.
+#
+# 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.
+"""Contains command to upload a large folder with the CLI."""
+
+import os
+from argparse import Namespace, _SubParsersAction
+from typing import List, Optional
+
+from huggingface_hub import logging
+from huggingface_hub.commands import BaseHuggingfaceCLICommand
+from huggingface_hub.hf_api import HfApi
+from huggingface_hub.utils import disable_progress_bars
+
+from ._cli_utils import ANSI
+
+
+logger = logging.get_logger(__name__)
+
+
+class UploadLargeFolderCommand(BaseHuggingfaceCLICommand):
+ @staticmethod
+ def register_subcommand(parser: _SubParsersAction):
+ subparser = parser.add_parser("upload-large-folder", help="Upload a large folder to a repo on the Hub")
+ subparser.add_argument(
+ "repo_id", type=str, help="The ID of the repo to upload to (e.g. `username/repo-name`)."
+ )
+ subparser.add_argument("local_path", type=str, help="Local path to the file or folder to upload.")
+ subparser.add_argument(
+ "--repo-type",
+ choices=["model", "dataset", "space"],
+ help="Type of the repo to upload to (e.g. `dataset`).",
+ )
+ subparser.add_argument(
+ "--revision",
+ type=str,
+ help=("An optional Git revision to push to. It can be a branch name or a PR reference."),
+ )
+ subparser.add_argument(
+ "--private",
+ action="store_true",
+ help=(
+ "Whether to create a private repo if repo doesn't exist on the Hub. Ignored if the repo already exists."
+ ),
+ )
+ subparser.add_argument("--include", nargs="*", type=str, help="Glob patterns to match files to upload.")
+ subparser.add_argument("--exclude", nargs="*", type=str, help="Glob patterns to exclude from files to upload.")
+ subparser.add_argument(
+ "--token", type=str, help="A User Access Token generated from https://huggingface.co/settings/tokens"
+ )
+ subparser.add_argument(
+ "--num-workers", type=int, help="Number of workers to use to hash, upload and commit files."
+ )
+ subparser.add_argument("--no-report", action="store_true", help="Whether to disable regular status report.")
+ subparser.add_argument("--no-bars", action="store_true", help="Whether to disable progress bars.")
+ subparser.set_defaults(func=UploadLargeFolderCommand)
+
+ def __init__(self, args: Namespace) -> None:
+ self.repo_id: str = args.repo_id
+ self.local_path: str = args.local_path
+ self.repo_type: str = args.repo_type
+ self.revision: Optional[str] = args.revision
+ self.private: bool = args.private
+
+ self.include: Optional[List[str]] = args.include
+ self.exclude: Optional[List[str]] = args.exclude
+
+ self.api: HfApi = HfApi(token=args.token, library_name="huggingface-cli")
+
+ self.num_workers: Optional[int] = args.num_workers
+ self.no_report: bool = args.no_report
+ self.no_bars: bool = args.no_bars
+
+ if not os.path.isdir(self.local_path):
+ raise ValueError("Large upload is only supported for folders.")
+
+ def run(self) -> None:
+ logging.set_verbosity_info()
+
+ print(
+ ANSI.yellow(
+ "You are about to upload a large folder to the Hub using `huggingface-cli upload-large-folder`. "
+ "This is a new feature so feedback is very welcome!\n"
+ "\n"
+ "A few things to keep in mind:\n"
+ " - Repository limits still apply: https://huggingface.co/docs/hub/repositories-recommendations\n"
+ " - Do not start several processes in parallel.\n"
+ " - You can interrupt and resume the process at any time. "
+ "The script will pick up where it left off except for partially uploaded files that would have to be entirely reuploaded.\n"
+ " - Do not upload the same folder to several repositories. If you need to do so, you must delete the `./.cache/huggingface/` folder first.\n"
+ "\n"
+ f"Some temporary metadata will be stored under `{self.local_path}/.cache/huggingface`.\n"
+ " - You must not modify those files manually.\n"
+ " - You must not delete the `./.cache/huggingface/` folder while a process is running.\n"
+ " - You can delete the `./.cache/huggingface/` folder to reinitialize the upload state when process is not running. Files will have to be hashed and preuploaded again, except for already committed files.\n"
+ "\n"
+ "If the process output is too verbose, you can disable the progress bars with `--no-bars`. "
+ "You can also entirely disable the status report with `--no-report`.\n"
+ "\n"
+ "For more details, run `huggingface-cli upload-large-folder --help` or check the documentation at "
+ "https://huggingface.co/docs/huggingface_hub/guides/upload#upload-a-large-folder."
+ )
+ )
+
+ if self.no_bars:
+ disable_progress_bars()
+
+ self.api.upload_large_folder(
+ repo_id=self.repo_id,
+ folder_path=self.local_path,
+ repo_type=self.repo_type,
+ revision=self.revision,
+ private=self.private,
+ allow_patterns=self.include,
+ ignore_patterns=self.exclude,
+ num_workers=self.num_workers,
+ print_report=not self.no_report,
+ )
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/commands/user.py b/parrot/lib/python3.10/site-packages/huggingface_hub/commands/user.py
new file mode 100644
index 0000000000000000000000000000000000000000..9741a219f17c951c9d20582a5756750b9b92630f
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/huggingface_hub/commands/user.py
@@ -0,0 +1,304 @@
+# Copyright 2020 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains commands to authenticate to the Hugging Face Hub and interact with your repositories.
+
+Usage:
+ # login and save token locally.
+ huggingface-cli login --token=hf_*** --add-to-git-credential
+
+ # switch between tokens
+ huggingface-cli auth switch
+
+ # list all tokens
+ huggingface-cli auth list
+
+ # logout from a specific token, if no token-name is provided, all tokens will be deleted from your machine.
+ huggingface-cli logout --token-name=your_token_name
+
+ # find out which huggingface.co account you are logged in as
+ huggingface-cli whoami
+
+ # create a new dataset repo on the Hub
+ huggingface-cli repo create mydataset --type=dataset
+
+"""
+
+import subprocess
+from argparse import _SubParsersAction
+from typing import List, Optional
+
+from requests.exceptions import HTTPError
+
+from huggingface_hub.commands import BaseHuggingfaceCLICommand
+from huggingface_hub.constants import ENDPOINT, REPO_TYPES, REPO_TYPES_URL_PREFIXES, SPACES_SDK_TYPES
+from huggingface_hub.hf_api import HfApi
+
+from .._login import ( # noqa: F401 # for backward compatibility # noqa: F401 # for backward compatibility
+ NOTEBOOK_LOGIN_PASSWORD_HTML,
+ NOTEBOOK_LOGIN_TOKEN_HTML_END,
+ NOTEBOOK_LOGIN_TOKEN_HTML_START,
+ auth_list,
+ auth_switch,
+ login,
+ logout,
+ notebook_login,
+)
+from ..utils import get_stored_tokens, get_token, logging
+from ._cli_utils import ANSI
+
+
+logger = logging.get_logger(__name__)
+
+try:
+ from InquirerPy import inquirer
+ from InquirerPy.base.control import Choice
+
+ _inquirer_py_available = True
+except ImportError:
+ _inquirer_py_available = False
+
+
+class UserCommands(BaseHuggingfaceCLICommand):
+ @staticmethod
+ def register_subcommand(parser: _SubParsersAction):
+ login_parser = parser.add_parser("login", help="Log in using a token from huggingface.co/settings/tokens")
+ login_parser.add_argument(
+ "--token",
+ type=str,
+ help="Token generated from https://huggingface.co/settings/tokens",
+ )
+ login_parser.add_argument(
+ "--add-to-git-credential",
+ action="store_true",
+ help="Optional: Save token to git credential helper.",
+ )
+ login_parser.set_defaults(func=lambda args: LoginCommand(args))
+ whoami_parser = parser.add_parser("whoami", help="Find out which huggingface.co account you are logged in as.")
+ whoami_parser.set_defaults(func=lambda args: WhoamiCommand(args))
+
+ logout_parser = parser.add_parser("logout", help="Log out")
+ logout_parser.add_argument(
+ "--token-name",
+ type=str,
+ help="Optional: Name of the access token to log out from.",
+ )
+ logout_parser.set_defaults(func=lambda args: LogoutCommand(args))
+
+ auth_parser = parser.add_parser("auth", help="Other authentication related commands")
+ auth_subparsers = auth_parser.add_subparsers(help="Authentication subcommands")
+ auth_switch_parser = auth_subparsers.add_parser("switch", help="Switch between access tokens")
+ auth_switch_parser.add_argument(
+ "--token-name",
+ type=str,
+ help="Optional: Name of the access token to switch to.",
+ )
+ auth_switch_parser.add_argument(
+ "--add-to-git-credential",
+ action="store_true",
+ help="Optional: Save token to git credential helper.",
+ )
+ auth_switch_parser.set_defaults(func=lambda args: AuthSwitchCommand(args))
+ auth_list_parser = auth_subparsers.add_parser("list", help="List all stored access tokens")
+ auth_list_parser.set_defaults(func=lambda args: AuthListCommand(args))
+ # new system: git-based repo system
+ repo_parser = parser.add_parser("repo", help="{create} Commands to interact with your huggingface.co repos.")
+ repo_subparsers = repo_parser.add_subparsers(help="huggingface.co repos related commands")
+ repo_create_parser = repo_subparsers.add_parser("create", help="Create a new repo on huggingface.co")
+ repo_create_parser.add_argument(
+ "name",
+ type=str,
+ help="Name for your repo. Will be namespaced under your username to build the repo id.",
+ )
+ repo_create_parser.add_argument(
+ "--type",
+ type=str,
+ help='Optional: repo_type: set to "dataset" or "space" if creating a dataset or space, default is model.',
+ )
+ repo_create_parser.add_argument("--organization", type=str, help="Optional: organization namespace.")
+ repo_create_parser.add_argument(
+ "--space_sdk",
+ type=str,
+ help='Optional: Hugging Face Spaces SDK type. Required when --type is set to "space".',
+ choices=SPACES_SDK_TYPES,
+ )
+ repo_create_parser.add_argument(
+ "-y",
+ "--yes",
+ action="store_true",
+ help="Optional: answer Yes to the prompt",
+ )
+ repo_create_parser.set_defaults(func=lambda args: RepoCreateCommand(args))
+
+
+class BaseUserCommand:
+ def __init__(self, args):
+ self.args = args
+ self._api = HfApi()
+
+
+class LoginCommand(BaseUserCommand):
+ def run(self):
+ logging.set_verbosity_info()
+ login(
+ token=self.args.token,
+ add_to_git_credential=self.args.add_to_git_credential,
+ )
+
+
+class LogoutCommand(BaseUserCommand):
+ def run(self):
+ logging.set_verbosity_info()
+ logout(token_name=self.args.token_name)
+
+
+class AuthSwitchCommand(BaseUserCommand):
+ def run(self):
+ logging.set_verbosity_info()
+ token_name = self.args.token_name
+ if token_name is None:
+ token_name = self._select_token_name()
+
+ if token_name is None:
+ print("No token name provided. Aborting.")
+ exit()
+ auth_switch(token_name, add_to_git_credential=self.args.add_to_git_credential)
+
+ def _select_token_name(self) -> Optional[str]:
+ token_names = list(get_stored_tokens().keys())
+
+ if not token_names:
+ logger.error("No stored tokens found. Please login first.")
+ return None
+
+ if _inquirer_py_available:
+ return self._select_token_name_tui(token_names)
+ # if inquirer is not available, use a simpler terminal UI
+ print("Available stored tokens:")
+ for i, token_name in enumerate(token_names, 1):
+ print(f"{i}. {token_name}")
+ while True:
+ try:
+ choice = input("Enter the number of the token to switch to (or 'q' to quit): ")
+ if choice.lower() == "q":
+ return None
+ index = int(choice) - 1
+ if 0 <= index < len(token_names):
+ return token_names[index]
+ else:
+ print("Invalid selection. Please try again.")
+ except ValueError:
+ print("Invalid input. Please enter a number or 'q' to quit.")
+
+ def _select_token_name_tui(self, token_names: List[str]) -> Optional[str]:
+ choices = [Choice(token_name, name=token_name) for token_name in token_names]
+ try:
+ return inquirer.select(
+ message="Select a token to switch to:",
+ choices=choices,
+ default=None,
+ ).execute()
+ except KeyboardInterrupt:
+ logger.info("Token selection cancelled.")
+ return None
+
+
+class AuthListCommand(BaseUserCommand):
+ def run(self):
+ logging.set_verbosity_info()
+ auth_list()
+
+
+class WhoamiCommand(BaseUserCommand):
+ def run(self):
+ token = get_token()
+ if token is None:
+ print("Not logged in")
+ exit()
+ try:
+ info = self._api.whoami(token)
+ print(info["name"])
+ orgs = [org["name"] for org in info["orgs"]]
+ if orgs:
+ print(ANSI.bold("orgs: "), ",".join(orgs))
+
+ if ENDPOINT != "https://huggingface.co":
+ print(f"Authenticated through private endpoint: {ENDPOINT}")
+ except HTTPError as e:
+ print(e)
+ print(ANSI.red(e.response.text))
+ exit(1)
+
+
+class RepoCreateCommand(BaseUserCommand):
+ def run(self):
+ token = get_token()
+ if token is None:
+ print("Not logged in")
+ exit(1)
+ try:
+ stdout = subprocess.check_output(["git", "--version"]).decode("utf-8")
+ print(ANSI.gray(stdout.strip()))
+ except FileNotFoundError:
+ print("Looks like you do not have git installed, please install.")
+
+ try:
+ stdout = subprocess.check_output(["git-lfs", "--version"]).decode("utf-8")
+ print(ANSI.gray(stdout.strip()))
+ except FileNotFoundError:
+ print(
+ ANSI.red(
+ "Looks like you do not have git-lfs installed, please install."
+ " You can install from https://git-lfs.github.com/."
+ " Then run `git lfs install` (you only have to do this once)."
+ )
+ )
+ print("")
+
+ user = self._api.whoami(token)["name"]
+ namespace = self.args.organization if self.args.organization is not None else user
+
+ repo_id = f"{namespace}/{self.args.name}"
+
+ if self.args.type not in REPO_TYPES:
+ print("Invalid repo --type")
+ exit(1)
+
+ if self.args.type in REPO_TYPES_URL_PREFIXES:
+ prefixed_repo_id = REPO_TYPES_URL_PREFIXES[self.args.type] + repo_id
+ else:
+ prefixed_repo_id = repo_id
+
+ print(f"You are about to create {ANSI.bold(prefixed_repo_id)}")
+
+ if not self.args.yes:
+ choice = input("Proceed? [Y/n] ").lower()
+ if not (choice == "" or choice == "y" or choice == "yes"):
+ print("Abort")
+ exit()
+ try:
+ url = self._api.create_repo(
+ repo_id=repo_id,
+ token=token,
+ repo_type=self.args.type,
+ space_sdk=self.args.space_sdk,
+ )
+ except HTTPError as e:
+ print(e)
+ print(ANSI.red(e.response.text))
+ exit(1)
+ print("\nYour repo now lives at:")
+ print(f" {ANSI.bold(url)}")
+ print("\nYou can clone it locally with the command below, and commit/push as usual.")
+ print(f"\n git clone {url}")
+ print("")
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/commands/version.py b/parrot/lib/python3.10/site-packages/huggingface_hub/commands/version.py
new file mode 100644
index 0000000000000000000000000000000000000000..f7e866b76f1dcbfbb90a4ec494c47cf3d61c17dd
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/huggingface_hub/commands/version.py
@@ -0,0 +1,37 @@
+# Copyright 2022 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains command to print information about the version.
+
+Usage:
+ huggingface-cli version
+"""
+
+from argparse import _SubParsersAction
+
+from huggingface_hub import __version__
+
+from . import BaseHuggingfaceCLICommand
+
+
+class VersionCommand(BaseHuggingfaceCLICommand):
+ def __init__(self, args):
+ self.args = args
+
+ @staticmethod
+ def register_subcommand(parser: _SubParsersAction):
+ version_parser = parser.add_parser("version", help="Print information about the huggingface-cli version.")
+ version_parser.set_defaults(func=VersionCommand)
+
+ def run(self) -> None:
+ print(f"huggingface_hub version: {__version__}")
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/inference/_generated/types/__pycache__/__init__.cpython-310.pyc b/parrot/lib/python3.10/site-packages/huggingface_hub/inference/_generated/types/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..85a22c700c85c0f9b829cbabcef530f610ec28bc
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/huggingface_hub/inference/_generated/types/__pycache__/__init__.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/inference/_generated/types/__pycache__/image_segmentation.cpython-310.pyc b/parrot/lib/python3.10/site-packages/huggingface_hub/inference/_generated/types/__pycache__/image_segmentation.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c8b1609273ba96b49e1e8d489397c28c48e11e1b
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/huggingface_hub/inference/_generated/types/__pycache__/image_segmentation.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/inference/_generated/types/__pycache__/image_to_text.cpython-310.pyc b/parrot/lib/python3.10/site-packages/huggingface_hub/inference/_generated/types/__pycache__/image_to_text.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d87dede8bcd788815c7e431852122d561f407d19
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/huggingface_hub/inference/_generated/types/__pycache__/image_to_text.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/inference/_generated/types/__pycache__/summarization.cpython-310.pyc b/parrot/lib/python3.10/site-packages/huggingface_hub/inference/_generated/types/__pycache__/summarization.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0ecd629387e8949cea13eccf573cba158b6c8871
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/huggingface_hub/inference/_generated/types/__pycache__/summarization.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/inference/_generated/types/__pycache__/text2text_generation.cpython-310.pyc b/parrot/lib/python3.10/site-packages/huggingface_hub/inference/_generated/types/__pycache__/text2text_generation.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..29a97b73db72267d8ca6c8511a88807b2be75097
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/huggingface_hub/inference/_generated/types/__pycache__/text2text_generation.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/inference/_generated/types/__pycache__/text_classification.cpython-310.pyc b/parrot/lib/python3.10/site-packages/huggingface_hub/inference/_generated/types/__pycache__/text_classification.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9f98afe8be9edb3a4b4a825bb705195be7754c6d
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/huggingface_hub/inference/_generated/types/__pycache__/text_classification.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/inference/_generated/types/__pycache__/text_to_audio.cpython-310.pyc b/parrot/lib/python3.10/site-packages/huggingface_hub/inference/_generated/types/__pycache__/text_to_audio.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..70b4f1d8ae1d8f1a799fb28792e990cb0c201950
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/huggingface_hub/inference/_generated/types/__pycache__/text_to_audio.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/inference/_generated/types/__pycache__/video_classification.cpython-310.pyc b/parrot/lib/python3.10/site-packages/huggingface_hub/inference/_generated/types/__pycache__/video_classification.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..aea96434c9fdc33f096273ec1d0d1c25a2834fd0
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/huggingface_hub/inference/_generated/types/__pycache__/video_classification.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/inference/_generated/types/__pycache__/visual_question_answering.cpython-310.pyc b/parrot/lib/python3.10/site-packages/huggingface_hub/inference/_generated/types/__pycache__/visual_question_answering.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..47eb8d1b46c15e77b7a5a7b975154dfb7dfcc011
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/huggingface_hub/inference/_generated/types/__pycache__/visual_question_answering.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/inference/_generated/types/__pycache__/zero_shot_classification.cpython-310.pyc b/parrot/lib/python3.10/site-packages/huggingface_hub/inference/_generated/types/__pycache__/zero_shot_classification.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..66aeecae29ba46ca6c03ddfc03a8090917d4537b
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/huggingface_hub/inference/_generated/types/__pycache__/zero_shot_classification.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/utils/_datetime.py b/parrot/lib/python3.10/site-packages/huggingface_hub/utils/_datetime.py
new file mode 100644
index 0000000000000000000000000000000000000000..1a7f44285d1c826006c97176ca66c3e9c33f61c0
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/huggingface_hub/utils/_datetime.py
@@ -0,0 +1,67 @@
+# coding=utf-8
+# Copyright 2022-present, the HuggingFace Inc. team.
+#
+# 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.
+"""Contains utilities to handle datetimes in Huggingface Hub."""
+
+from datetime import datetime, timezone
+
+
+def parse_datetime(date_string: str) -> datetime:
+ """
+ Parses a date_string returned from the server to a datetime object.
+
+ This parser is a weak-parser is the sense that it handles only a single format of
+ date_string. It is expected that the server format will never change. The
+ implementation depends only on the standard lib to avoid an external dependency
+ (python-dateutil). See full discussion about this decision on PR:
+ https://github.com/huggingface/huggingface_hub/pull/999.
+
+ Example:
+ ```py
+ > parse_datetime('2022-08-19T07:19:38.123Z')
+ datetime.datetime(2022, 8, 19, 7, 19, 38, 123000, tzinfo=timezone.utc)
+ ```
+
+ Args:
+ date_string (`str`):
+ A string representing a datetime returned by the Hub server.
+ String is expected to follow '%Y-%m-%dT%H:%M:%S.%fZ' pattern.
+
+ Returns:
+ A python datetime object.
+
+ Raises:
+ :class:`ValueError`:
+ If `date_string` cannot be parsed.
+ """
+ try:
+ # Normalize the string to always have 6 digits of fractional seconds
+ if date_string.endswith("Z"):
+ # Case 1: No decimal point (e.g., "2024-11-16T00:27:02Z")
+ if "." not in date_string:
+ # No fractional seconds - insert .000000
+ date_string = date_string[:-1] + ".000000Z"
+ # Case 2: Has decimal point (e.g., "2022-08-19T07:19:38.123456789Z")
+ else:
+ # Get the fractional and base parts
+ base, fraction = date_string[:-1].split(".")
+ # fraction[:6] takes first 6 digits and :0<6 pads with zeros if less than 6 digits
+ date_string = f"{base}.{fraction[:6]:0<6}Z"
+
+ return datetime.strptime(date_string, "%Y-%m-%dT%H:%M:%S.%fZ").replace(tzinfo=timezone.utc)
+ except ValueError as e:
+ raise ValueError(
+ f"Cannot parse '{date_string}' as a datetime. Date string is expected to"
+ " follow '%Y-%m-%dT%H:%M:%S.%fZ' pattern."
+ ) from e
diff --git a/parrot/lib/python3.10/site-packages/huggingface_hub/utils/_fixes.py b/parrot/lib/python3.10/site-packages/huggingface_hub/utils/_fixes.py
new file mode 100644
index 0000000000000000000000000000000000000000..560003b6222058b03791491b1ce70ea9d7a94404
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/huggingface_hub/utils/_fixes.py
@@ -0,0 +1,133 @@
+# JSONDecodeError was introduced in requests=2.27 released in 2022.
+# This allows us to support older requests for users
+# More information: https://github.com/psf/requests/pull/5856
+try:
+ from requests import JSONDecodeError # type: ignore # noqa: F401
+except ImportError:
+ try:
+ from simplejson import JSONDecodeError # type: ignore # noqa: F401
+ except ImportError:
+ from json import JSONDecodeError # type: ignore # noqa: F401
+import contextlib
+import os
+import shutil
+import stat
+import tempfile
+import time
+from functools import partial
+from pathlib import Path
+from typing import Callable, Generator, Optional, Union
+
+import yaml
+from filelock import BaseFileLock, FileLock, SoftFileLock, Timeout
+
+from .. import constants
+from . import logging
+
+
+logger = logging.get_logger(__name__)
+
+# Wrap `yaml.dump` to set `allow_unicode=True` by default.
+#
+# Example:
+# ```py
+# >>> yaml.dump({"emoji": "π", "some unicode": "ζ₯ζ¬γ"})
+# 'emoji: "\\U0001F440"\nsome unicode: "\\u65E5\\u672C\\u304B"\n'
+#
+# >>> yaml_dump({"emoji": "π", "some unicode": "ζ₯ζ¬γ"})
+# 'emoji: "π"\nsome unicode: "ζ₯ζ¬γ"\n'
+# ```
+yaml_dump: Callable[..., str] = partial(yaml.dump, stream=None, allow_unicode=True) # type: ignore
+
+
+@contextlib.contextmanager
+def SoftTemporaryDirectory(
+ suffix: Optional[str] = None,
+ prefix: Optional[str] = None,
+ dir: Optional[Union[Path, str]] = None,
+ **kwargs,
+) -> Generator[Path, None, None]:
+ """
+ Context manager to create a temporary directory and safely delete it.
+
+ If tmp directory cannot be deleted normally, we set the WRITE permission and retry.
+ If cleanup still fails, we give up but don't raise an exception. This is equivalent
+ to `tempfile.TemporaryDirectory(..., ignore_cleanup_errors=True)` introduced in
+ Python 3.10.
+
+ See https://www.scivision.dev/python-tempfile-permission-error-windows/.
+ """
+ tmpdir = tempfile.TemporaryDirectory(prefix=prefix, suffix=suffix, dir=dir, **kwargs)
+ yield Path(tmpdir.name).resolve()
+
+ try:
+ # First once with normal cleanup
+ shutil.rmtree(tmpdir.name)
+ except Exception:
+ # If failed, try to set write permission and retry
+ try:
+ shutil.rmtree(tmpdir.name, onerror=_set_write_permission_and_retry)
+ except Exception:
+ pass
+
+ # And finally, cleanup the tmpdir.
+ # If it fails again, give up but do not throw error
+ try:
+ tmpdir.cleanup()
+ except Exception:
+ pass
+
+
+def _set_write_permission_and_retry(func, path, excinfo):
+ os.chmod(path, stat.S_IWRITE)
+ func(path)
+
+
+@contextlib.contextmanager
+def WeakFileLock(
+ lock_file: Union[str, Path], *, timeout: Optional[float] = None
+) -> Generator[BaseFileLock, None, None]:
+ """A filelock with some custom logic.
+
+ This filelock is weaker than the default filelock in that:
+ 1. It won't raise an exception if release fails.
+ 2. It will default to a SoftFileLock if the filesystem does not support flock.
+
+ An INFO log message is emitted every 10 seconds if the lock is not acquired immediately.
+ If a timeout is provided, a `filelock.Timeout` exception is raised if the lock is not acquired within the timeout.
+ """
+ log_interval = constants.FILELOCK_LOG_EVERY_SECONDS
+ lock = FileLock(lock_file, timeout=log_interval)
+ start_time = time.time()
+
+ while True:
+ elapsed_time = time.time() - start_time
+ if timeout is not None and elapsed_time >= timeout:
+ raise Timeout(str(lock_file))
+
+ try:
+ lock.acquire(timeout=min(log_interval, timeout - elapsed_time) if timeout else log_interval)
+ except Timeout:
+ logger.info(
+ f"Still waiting to acquire lock on {lock_file} (elapsed: {time.time() - start_time:.1f} seconds)"
+ )
+ except NotImplementedError as e:
+ if "use SoftFileLock instead" in str(e):
+ logger.warning(
+ "FileSystem does not appear to support flock. Falling back to SoftFileLock for %s", lock_file
+ )
+ lock = SoftFileLock(lock_file, timeout=log_interval)
+ continue
+ else:
+ break
+
+ try:
+ yield lock
+ finally:
+ try:
+ lock.release()
+ except OSError:
+ try:
+ Path(lock_file).unlink()
+ except OSError:
+ pass
diff --git a/parrot/lib/python3.10/site-packages/typing_extensions-4.12.2.dist-info/LICENSE b/parrot/lib/python3.10/site-packages/typing_extensions-4.12.2.dist-info/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..f26bcf4d2de6eb136e31006ca3ab447d5e488adf
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/typing_extensions-4.12.2.dist-info/LICENSE
@@ -0,0 +1,279 @@
+A. HISTORY OF THE SOFTWARE
+==========================
+
+Python was created in the early 1990s by Guido van Rossum at Stichting
+Mathematisch Centrum (CWI, see https://www.cwi.nl) in the Netherlands
+as a successor of a language called ABC. Guido remains Python's
+principal author, although it includes many contributions from others.
+
+In 1995, Guido continued his work on Python at the Corporation for
+National Research Initiatives (CNRI, see https://www.cnri.reston.va.us)
+in Reston, Virginia where he released several versions of the
+software.
+
+In May 2000, Guido and the Python core development team moved to
+BeOpen.com to form the BeOpen PythonLabs team. In October of the same
+year, the PythonLabs team moved to Digital Creations, which became
+Zope Corporation. In 2001, the Python Software Foundation (PSF, see
+https://www.python.org/psf/) was formed, a non-profit organization
+created specifically to own Python-related Intellectual Property.
+Zope Corporation was a sponsoring member of the PSF.
+
+All Python releases are Open Source (see https://opensource.org for
+the Open Source Definition). Historically, most, but not all, Python
+releases have also been GPL-compatible; the table below summarizes
+the various releases.
+
+ Release Derived Year Owner GPL-
+ from compatible? (1)
+
+ 0.9.0 thru 1.2 1991-1995 CWI yes
+ 1.3 thru 1.5.2 1.2 1995-1999 CNRI yes
+ 1.6 1.5.2 2000 CNRI no
+ 2.0 1.6 2000 BeOpen.com no
+ 1.6.1 1.6 2001 CNRI yes (2)
+ 2.1 2.0+1.6.1 2001 PSF no
+ 2.0.1 2.0+1.6.1 2001 PSF yes
+ 2.1.1 2.1+2.0.1 2001 PSF yes
+ 2.1.2 2.1.1 2002 PSF yes
+ 2.1.3 2.1.2 2002 PSF yes
+ 2.2 and above 2.1.1 2001-now PSF yes
+
+Footnotes:
+
+(1) GPL-compatible doesn't mean that we're distributing Python under
+ the GPL. All Python licenses, unlike the GPL, let you distribute
+ a modified version without making your changes open source. The
+ GPL-compatible licenses make it possible to combine Python with
+ other software that is released under the GPL; the others don't.
+
+(2) According to Richard Stallman, 1.6.1 is not GPL-compatible,
+ because its license has a choice of law clause. According to
+ CNRI, however, Stallman's lawyer has told CNRI's lawyer that 1.6.1
+ is "not incompatible" with the GPL.
+
+Thanks to the many outside volunteers who have worked under Guido's
+direction to make these releases possible.
+
+
+B. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PYTHON
+===============================================================
+
+Python software and documentation are licensed under the
+Python Software Foundation License Version 2.
+
+Starting with Python 3.8.6, examples, recipes, and other code in
+the documentation are dual licensed under the PSF License Version 2
+and the Zero-Clause BSD license.
+
+Some software incorporated into Python is under different licenses.
+The licenses are listed with code falling under that license.
+
+
+PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+--------------------------------------------
+
+1. This LICENSE AGREEMENT is between the Python Software Foundation
+("PSF"), and the Individual or Organization ("Licensee") accessing and
+otherwise using this software ("Python") in source or binary form and
+its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, PSF hereby
+grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
+analyze, test, perform and/or display publicly, prepare derivative works,
+distribute, and otherwise use Python alone or in any derivative version,
+provided, however, that PSF's License Agreement and PSF's notice of copyright,
+i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 Python Software Foundation;
+All Rights Reserved" are retained in Python alone or in any derivative version
+prepared by Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python.
+
+4. PSF is making Python available to Licensee on an "AS IS"
+basis. PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any
+relationship of agency, partnership, or joint venture between PSF and
+Licensee. This License Agreement does not grant permission to use PSF
+trademarks or trade name in a trademark sense to endorse or promote
+products or services of Licensee, or any third party.
+
+8. By copying, installing or otherwise using Python, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
+
+
+BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0
+-------------------------------------------
+
+BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1
+
+1. This LICENSE AGREEMENT is between BeOpen.com ("BeOpen"), having an
+office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the
+Individual or Organization ("Licensee") accessing and otherwise using
+this software in source or binary form and its associated
+documentation ("the Software").
+
+2. Subject to the terms and conditions of this BeOpen Python License
+Agreement, BeOpen hereby grants Licensee a non-exclusive,
+royalty-free, world-wide license to reproduce, analyze, test, perform
+and/or display publicly, prepare derivative works, distribute, and
+otherwise use the Software alone or in any derivative version,
+provided, however, that the BeOpen Python License is retained in the
+Software, alone or in any derivative version prepared by Licensee.
+
+3. BeOpen is making the Software available to Licensee on an "AS IS"
+basis. BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE
+SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS
+AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY
+DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+5. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+6. This License Agreement shall be governed by and interpreted in all
+respects by the law of the State of California, excluding conflict of
+law provisions. Nothing in this License Agreement shall be deemed to
+create any relationship of agency, partnership, or joint venture
+between BeOpen and Licensee. This License Agreement does not grant
+permission to use BeOpen trademarks or trade names in a trademark
+sense to endorse or promote products or services of Licensee, or any
+third party. As an exception, the "BeOpen Python" logos available at
+http://www.pythonlabs.com/logos.html may be used according to the
+permissions granted on that web page.
+
+7. By copying, installing or otherwise using the software, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
+
+
+CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1
+---------------------------------------
+
+1. This LICENSE AGREEMENT is between the Corporation for National
+Research Initiatives, having an office at 1895 Preston White Drive,
+Reston, VA 20191 ("CNRI"), and the Individual or Organization
+("Licensee") accessing and otherwise using Python 1.6.1 software in
+source or binary form and its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, CNRI
+hereby grants Licensee a nonexclusive, royalty-free, world-wide
+license to reproduce, analyze, test, perform and/or display publicly,
+prepare derivative works, distribute, and otherwise use Python 1.6.1
+alone or in any derivative version, provided, however, that CNRI's
+License Agreement and CNRI's notice of copyright, i.e., "Copyright (c)
+1995-2001 Corporation for National Research Initiatives; All Rights
+Reserved" are retained in Python 1.6.1 alone or in any derivative
+version prepared by Licensee. Alternately, in lieu of CNRI's License
+Agreement, Licensee may substitute the following text (omitting the
+quotes): "Python 1.6.1 is made available subject to the terms and
+conditions in CNRI's License Agreement. This Agreement together with
+Python 1.6.1 may be located on the internet using the following
+unique, persistent identifier (known as a handle): 1895.22/1013. This
+Agreement may also be obtained from a proxy server on the internet
+using the following URL: http://hdl.handle.net/1895.22/1013".
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python 1.6.1 or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python 1.6.1.
+
+4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS"
+basis. CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. This License Agreement shall be governed by the federal
+intellectual property law of the United States, including without
+limitation the federal copyright law, and, to the extent such
+U.S. federal law does not apply, by the law of the Commonwealth of
+Virginia, excluding Virginia's conflict of law provisions.
+Notwithstanding the foregoing, with regard to derivative works based
+on Python 1.6.1 that incorporate non-separable material that was
+previously distributed under the GNU General Public License (GPL), the
+law of the Commonwealth of Virginia shall govern this License
+Agreement only as to issues arising under or with respect to
+Paragraphs 4, 5, and 7 of this License Agreement. Nothing in this
+License Agreement shall be deemed to create any relationship of
+agency, partnership, or joint venture between CNRI and Licensee. This
+License Agreement does not grant permission to use CNRI trademarks or
+trade name in a trademark sense to endorse or promote products or
+services of Licensee, or any third party.
+
+8. By clicking on the "ACCEPT" button where indicated, or by copying,
+installing or otherwise using Python 1.6.1, Licensee agrees to be
+bound by the terms and conditions of this License Agreement.
+
+ ACCEPT
+
+
+CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2
+--------------------------------------------------
+
+Copyright (c) 1991 - 1995, Stichting Mathematisch Centrum Amsterdam,
+The Netherlands. All rights reserved.
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Stichting Mathematisch
+Centrum or CWI not be used in advertising or publicity pertaining to
+distribution of the software without specific, written prior
+permission.
+
+STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
+THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
+FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+ZERO-CLAUSE BSD LICENSE FOR CODE IN THE PYTHON DOCUMENTATION
+----------------------------------------------------------------------
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
diff --git a/parrot/lib/python3.10/site-packages/typing_extensions-4.12.2.dist-info/RECORD b/parrot/lib/python3.10/site-packages/typing_extensions-4.12.2.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..bd92186bcb33df164ab86970c46512e7d818e772
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/typing_extensions-4.12.2.dist-info/RECORD
@@ -0,0 +1,8 @@
+__pycache__/typing_extensions.cpython-310.pyc,,
+typing_extensions-4.12.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+typing_extensions-4.12.2.dist-info/LICENSE,sha256=Oy-B_iHRgcSZxZolbI4ZaEVdZonSaaqFNzv7avQdo78,13936
+typing_extensions-4.12.2.dist-info/METADATA,sha256=BeUQIa8cnYbrjWx-N8TOznM9UGW5Gm2DicVpDtRA8W0,3018
+typing_extensions-4.12.2.dist-info/RECORD,,
+typing_extensions-4.12.2.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+typing_extensions-4.12.2.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
+typing_extensions.py,sha256=gwekpyG9DVG3lxWKX4ni8u7nk3We5slG98mA9F3DJQw,134451
diff --git a/parrot/lib/python3.10/site-packages/typing_extensions-4.12.2.dist-info/REQUESTED b/parrot/lib/python3.10/site-packages/typing_extensions-4.12.2.dist-info/REQUESTED
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391