+License: MIT
+Project-URL: Changelog, https://github.com/jawah/charset_normalizer/blob/master/CHANGELOG.md
+Project-URL: Documentation, https://charset-normalizer.readthedocs.io/
+Project-URL: Code, https://github.com/jawah/charset_normalizer
+Project-URL: Issue tracker, https://github.com/jawah/charset_normalizer/issues
+Keywords: encoding,charset,charset-detector,detector,normalization,unicode,chardet,detect
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+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 :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Programming Language :: Python :: Free Threading :: 4 - Resilient
+Classifier: Topic :: Text Processing :: Linguistic
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: unicode-backport
+Dynamic: license-file
+
+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.
+> You can also register your own set of codecs, and yes, it would work as-is.
+
+
+ >>>>> 👉 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`[^1] | ❌ | ✅ | ❌ |
+| `Reliable` **without** distinguishable standards | ✅ | ✅ | ✅ |
+| `Reliable` **with** distinguishable standards | ✅ | ✅ | ✅ |
+| `License` | _Disputed_[^2]
_restrictive_ | MIT | MPL-1.1
_restrictive_ |
+| `Native Python` | ✅ | ✅ | ❌ |
+| `Detect spoken language` | ✅ | ✅ | N/A |
+| `UnicodeDecodeError Safety` | ✅ | ✅ | ❌ |
+| `Whl Size (min)` | 500 kB | 150 kB | ~200 kB |
+| `Supported Encoding` | 99 | [99](https://charset-normalizer.readthedocs.io/en/latest/user/support.html#supported-encodings) | 40 |
+| `Can register custom encoding` | ❌ | ✅ | ❌ |
+
+
+
+
+
+[^1]: They are clearly using specific code for a specific encoding even if covering most of used one.
+[^2]: Chardet 7.0+ was relicensed from LGPL-2.1 to MIT following an AI-assisted rewrite. This relicensing is disputed on two independent grounds: **(a)** the original author [contests](https://github.com/chardet/chardet/issues/327) that the maintainer had the right to relicense, arguing the rewrite is a derivative work of the LGPL-licensed codebase since it was not a clean room implementation; **(b)** the copyright claim itself is [questionable](https://github.com/chardet/chardet/issues/334) given the code was primarily generated by an LLM, and AI-generated output may not be copyrightable under most jurisdictions. Either issue alone could undermine the MIT license. Beyond licensing, the rewrite raises questions about responsible use of AI in open source: key architectural ideas pioneered by charset-normalizer - notably decode-first validity filtering (our foundational approach since v1) and encoding pairwise similarity with the same algorithm and threshold — surfaced in chardet 7 without acknowledgment. The project also imported test files from charset-normalizer to train and benchmark against it, then claimed superior accuracy on those very files. Charset-normalizer has always been MIT-licensed, encoding-agnostic by design, and built on a verifiable human-authored history.
+
+## ⚡ Performance
+
+This package offer better performances (99th, and 95th) against Chardet. Here are some numbers.
+
+| Package | Accuracy | Mean per file (ms) | File per sec (est) |
+|---------------------------------------------------|:--------:|:------------------:|:------------------:|
+| [chardet 7.1](https://github.com/chardet/chardet) | 89 % | 3 ms | 333 file/sec |
+| charset-normalizer | **97 %** | 3 ms | 333 file/sec |
+
+| Package | 99th percentile | 95th percentile | 50th percentile |
+|---------------------------------------------------|:---------------:|:---------------:|:---------------:|
+| [chardet 7.1](https://github.com/chardet/chardet) | 32 ms | 17 ms | < 1 ms |
+| charset-normalizer | 16 ms | 10 ms | 1 ms |
+
+_updated as of March 2026 using CPython 3.12, Charset-Normalizer 3.4.6, and Chardet 7.1.0_
+
+~Chardet's performance on larger file (1MB+) are very poor. Expect huge difference on large payload.~ No longer the case since Chardet 7.0+
+
+> 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.
+> Chardet claims on his documentation to have a greater accuracy than us based on the dataset they trained Chardet on(...)
+> Well, it's normal, the opposite would have been worrying. Whereas charset-normalizer don't train on anything, our solution
+> is based on a completely different algorithm, still heuristic through, it does not need weights across every encoding tables.
+
+## ✨ 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 (aka. defining noise in rendered text).
+ 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
+
+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
+
+[](https://www.bestpractices.dev/projects/7297)
+
+# 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.4.7](https://github.com/Ousret/charset_normalizer/compare/3.4.6...3.4.7) (2026-04-02)
+
+### Changed
+- Pre-built optimized version using mypy[c] v1.20.
+- Relax `setuptools` constraint to `setuptools>=68,<82.1`.
+
+### Fixed
+- Correctly remove SIG remnant in utf-7 decoded string. (#718) (#716)
+
+## [3.4.6](https://github.com/Ousret/charset_normalizer/compare/3.4.5...3.4.6) (2026-03-15)
+
+### Changed
+- Flattened the logic in `charset_normalizer.md` for higher performance. Removed `eligible(..)` and `feed(...)`
+ in favor of `feed_info(...)`.
+- Raised upper bound for mypy[c] to 1.20, for our optimized version.
+- Updated `UNICODE_RANGES_COMBINED` using Unicode blocks v17.
+
+### Fixed
+- Edge case where noise difference between two candidates can be almost insignificant. (#672)
+- CLI `--normalize` writing to wrong path when passing multiple files in. (#702)
+
+### Misc
+- Freethreaded pre-built wheels now shipped in PyPI starting with 3.14t. (#616)
+
+## [3.4.5](https://github.com/Ousret/charset_normalizer/compare/3.4.4...3.4.5) (2026-03-06)
+
+### Changed
+- Update `setuptools` constraint to `setuptools>=68,<=82`.
+- Raised upper bound of mypyc for the optional pre-built extension to v1.19.1
+
+### Fixed
+- Add explicit link to lib math in our optimized build. (#692)
+- Logger level not restored correctly for empty byte sequences. (#701)
+- TypeError when passing bytearray to from_bytes. (#703)
+
+### Misc
+- Applied safe micro-optimizations in both our noise detector and language detector.
+- Rewrote the `query_yes_no` function (inside CLI) to avoid using ambiguous licensed code.
+- Added `cd.py` submodule into mypyc optional compilation to reduce further the performance impact.
+
+## [3.4.4](https://github.com/Ousret/charset_normalizer/compare/3.4.2...3.4.4) (2025-10-13)
+
+### Changed
+- Bound `setuptools` to a specific constraint `setuptools>=68,<=81`.
+- Raised upper bound of mypyc for the optional pre-built extension to v1.18.2
+
+### Removed
+- `setuptools-scm` as a build dependency.
+
+### Misc
+- Enforced hashes in `dev-requirements.txt` and created `ci-requirements.txt` for security purposes.
+- Additional pre-built wheels for riscv64, s390x, and armv7l architectures.
+- Restore ` multiple.intoto.jsonl` in GitHub releases in addition to individual attestation file per wheel.
+
+## [3.4.3](https://github.com/Ousret/charset_normalizer/compare/3.4.2...3.4.3) (2025-08-09)
+
+### Changed
+- mypy(c) is no longer a required dependency at build time if `CHARSET_NORMALIZER_USE_MYPYC` isn't set to `1`. (#595) (#583)
+- automatically lower confidence on small bytes samples that are not Unicode in `detect` output legacy function. (#391)
+
+### Added
+- Custom build backend to overcome inability to mark mypy as an optional dependency in the build phase.
+- Support for Python 3.14
+
+### Fixed
+- sdist archive contained useless directories.
+- automatically fallback on valid UTF-16 or UTF-32 even if the md says it's noisy. (#633)
+
+### Misc
+- SBOM are automatically published to the relevant GitHub release to comply with regulatory changes.
+ Each published wheel comes with its SBOM. We choose CycloneDX as the format.
+- Prebuilt optimized wheel are no longer distributed by default for CPython 3.7 due to a change in cibuildwheel.
+
+## [3.4.2](https://github.com/Ousret/charset_normalizer/compare/3.4.1...3.4.2) (2025-05-02)
+
+### Fixed
+- Addressed the DeprecationWarning in our CLI regarding `argparse.FileType` by backporting the target class into the package. (#591)
+- Improved the overall reliability of the detector with CJK Ideographs. (#605) (#587)
+
+### Changed
+- Optional mypyc compilation upgraded to version 1.15 for Python >= 3.8
+
+## [3.4.1](https://github.com/Ousret/charset_normalizer/compare/3.4.0...3.4.1) (2024-12-24)
+
+### Changed
+- Project metadata are now stored using `pyproject.toml` instead of `setup.cfg` using setuptools as the build backend.
+- Enforce annotation delayed loading for a simpler and consistent types in the project.
+- Optional mypyc compilation upgraded to version 1.14 for Python >= 3.8
+
+### Added
+- pre-commit configuration.
+- noxfile.
+
+### Removed
+- `build-requirements.txt` as per using `pyproject.toml` native build configuration.
+- `bin/integration.py` and `bin/serve.py` in favor of downstream integration test (see noxfile).
+- `setup.cfg` in favor of `pyproject.toml` metadata configuration.
+- Unused `utils.range_scan` function.
+
+### Fixed
+- Converting content to Unicode bytes may insert `utf_8` instead of preferred `utf-8`. (#572)
+- Deprecation warning "'count' is passed as positional argument" when converting to Unicode bytes on Python 3.13+
+
+## [3.4.0](https://github.com/Ousret/charset_normalizer/compare/3.3.2...3.4.0) (2024-10-08)
+
+### Added
+- Argument `--no-preemptive` in the CLI to prevent the detector to search for hints.
+- Support for Python 3.13 (#512)
+
+### Fixed
+- Relax the TypeError exception thrown when trying to compare a CharsetMatch with anything else than a CharsetMatch.
+- Improved the general reliability of the detector based on user feedbacks. (#520) (#509) (#498) (#407) (#537)
+- Declared charset in content (preemptive detection) not changed when converting to utf-8 bytes. (#381)
+
+## [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) 2025 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/python/user_packages/Python313/site-packages/charset_normalizer-3.4.7.dist-info/RECORD b/python/user_packages/Python313/site-packages/charset_normalizer-3.4.7.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..80a9862b722e282a67816bd032adc2254f8bc4b4
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/charset_normalizer-3.4.7.dist-info/RECORD
@@ -0,0 +1,36 @@
+../Scripts/normalizer.exe,sha256=sRGERbzhlOVuuuWnPuMJtCa9IV_2_rhzbtQ3Y6-aIqk,108356
+81d243bd2c585b0f4821__mypyc.cp313-win_amd64.pyd,sha256=un_FRJlPEmy3SFzlLSZdLzLpPE8eofzW_N7jkY8nGXk,218624
+charset_normalizer-3.4.7.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+charset_normalizer-3.4.7.dist-info/METADATA,sha256=0llkYJSRRJSKgCIy09lSxe0sJGV1SBWfRvNSjKX5-rs,41739
+charset_normalizer-3.4.7.dist-info/RECORD,,
+charset_normalizer-3.4.7.dist-info/WHEEL,sha256=x5Wpw_tLx5PQKiWdxpqvs0e7Sg-SO0mTWdEADYDGPGA,101
+charset_normalizer-3.4.7.dist-info/entry_points.txt,sha256=ADSTKrkXZ3hhdOVFi6DcUEHQRS0xfxDIE_pEz4wLIXA,65
+charset_normalizer-3.4.7.dist-info/licenses/LICENSE,sha256=GFd0hdNwTxpHne2OVzwJds_tMV_S_ReYP6mI2kwvcNE,1092
+charset_normalizer-3.4.7.dist-info/top_level.txt,sha256=c_vZbitqecT2GfK3zdxSTLCn8C-6pGnHQY5o_5Y32M0,47
+charset_normalizer/__init__.py,sha256=0NT8MHi7SKq3juMqYfOdrkzjisK0L73lneNHH4qaUAs,1638
+charset_normalizer/__main__.py,sha256=2sj_BS6H0sU25C1bMqz9DVwa6kOK9lchSEbSU-_iu7M,115
+charset_normalizer/__pycache__/__init__.cpython-313.pyc,,
+charset_normalizer/__pycache__/__main__.cpython-313.pyc,,
+charset_normalizer/__pycache__/api.cpython-313.pyc,,
+charset_normalizer/__pycache__/cd.cpython-313.pyc,,
+charset_normalizer/__pycache__/constant.cpython-313.pyc,,
+charset_normalizer/__pycache__/legacy.cpython-313.pyc,,
+charset_normalizer/__pycache__/md.cpython-313.pyc,,
+charset_normalizer/__pycache__/models.cpython-313.pyc,,
+charset_normalizer/__pycache__/utils.cpython-313.pyc,,
+charset_normalizer/__pycache__/version.cpython-313.pyc,,
+charset_normalizer/api.py,sha256=mHkwxdTIzOWLNDsADQ0IpedjW8MY0VNWan1MMexenfc,39832
+charset_normalizer/cd.cp313-win_amd64.pyd,sha256=Lp9QSbPF23q3jGq7lN-7_gNeurj0BZQyD4ySIh9IbyQ,10752
+charset_normalizer/cd.py,sha256=oxPRzNqGqGMm6V4Os7lI2jQK_Pe8vgzEOWtIH4FWYhQ,15628
+charset_normalizer/cli/__init__.py,sha256=d9MUx-1V_qD3x9igIy4JT4oC5CU0yjulk7QyZWeRFhg,144
+charset_normalizer/cli/__main__.py,sha256=8TfOJ7pE3_USMlquyzg1TnEvSWdshj3Vmycsmsd0EJA,12302
+charset_normalizer/cli/__pycache__/__init__.cpython-313.pyc,,
+charset_normalizer/cli/__pycache__/__main__.cpython-313.pyc,,
+charset_normalizer/constant.py,sha256=CA94LLkydl625rnSViIv_egUOpzZx1mAAUmCu3QN5mQ,46481
+charset_normalizer/legacy.py,sha256=MCz6fcVj-h_VG9lMgnMUibESu4iAQqznE6HbMdleQIM,2740
+charset_normalizer/md.cp313-win_amd64.pyd,sha256=FNWEDqebdpDlCuaxgsG3YF4Cpqi440o_ngnb-1lGi9I,10752
+charset_normalizer/md.py,sha256=_Sv-zOZTD64bz7LsMcs5GEOBdJdvYreOiVjtUiEcVuU,31377
+charset_normalizer/models.py,sha256=wzkS2p-SXFmfOcGhs5Xt_eke1OwxthBGCXwSkAMG2_c,13190
+charset_normalizer/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+charset_normalizer/utils.py,sha256=NzMBuvIt5IZ5_sYqboqJs7L1X_uWhwz5RfPWBYaDPX0,12704
+charset_normalizer/version.py,sha256=R38VXV25CgZdFHNOs5FpuL29tVaU302SYUBvWpWCVNw,123
diff --git a/python/user_packages/Python313/site-packages/charset_normalizer-3.4.7.dist-info/WHEEL b/python/user_packages/Python313/site-packages/charset_normalizer-3.4.7.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..f787649e12bd5d319b7ec43d32cec8d136ef81e5
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/charset_normalizer-3.4.7.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: false
+Tag: cp313-cp313-win_amd64
+
diff --git a/python/user_packages/Python313/site-packages/charset_normalizer-3.4.7.dist-info/entry_points.txt b/python/user_packages/Python313/site-packages/charset_normalizer-3.4.7.dist-info/entry_points.txt
new file mode 100644
index 0000000000000000000000000000000000000000..65619e73ec06c20c2a70c9507b872ad624d1a85c
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/charset_normalizer-3.4.7.dist-info/entry_points.txt
@@ -0,0 +1,2 @@
+[console_scripts]
+normalizer = charset_normalizer.cli:cli_detect
diff --git a/python/user_packages/Python313/site-packages/charset_normalizer-3.4.7.dist-info/top_level.txt b/python/user_packages/Python313/site-packages/charset_normalizer-3.4.7.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..89847bead5357e0f635d338a19f78f50e41d2080
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/charset_normalizer-3.4.7.dist-info/top_level.txt
@@ -0,0 +1,2 @@
+81d243bd2c585b0f4821__mypyc
+charset_normalizer
diff --git a/python/user_packages/Python313/site-packages/charset_normalizer/__init__.py b/python/user_packages/Python313/site-packages/charset_normalizer/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1993f86a9d55ddc3f2b7c1dcd92a0ed55a5637ce
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/charset_normalizer/__init__.py
@@ -0,0 +1,48 @@
+"""
+Charset-Normalizer
+~~~~~~~~~~~~~~
+The Real First Universal Charset Detector.
+A library that helps you read text from an unknown charset encoding.
+Motivated by chardet, This package is 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.
+
+Basic usage:
+ >>> from charset_normalizer import from_bytes
+ >>> results = from_bytes('Bсеки човек има право на образование. Oбразованието!'.encode('utf_8'))
+ >>> best_guess = results.best()
+ >>> str(best_guess)
+ 'Bсеки човек има право на образование. Oбразованието!'
+
+Others methods and usages are available - see the full documentation
+at .
+:copyright: (c) 2021 by Ahmed TAHRI
+:license: MIT, see LICENSE for more details.
+"""
+
+from __future__ import annotations
+
+import logging
+
+from .api import from_bytes, from_fp, from_path, is_binary
+from .legacy import detect
+from .models import CharsetMatch, CharsetMatches
+from .utils import set_logging_handler
+from .version import VERSION, __version__
+
+__all__ = (
+ "from_fp",
+ "from_path",
+ "from_bytes",
+ "is_binary",
+ "detect",
+ "CharsetMatch",
+ "CharsetMatches",
+ "__version__",
+ "VERSION",
+ "set_logging_handler",
+)
+
+# Attach a NullHandler to the top level logger by default
+# https://docs.python.org/3.3/howto/logging.html#configuring-logging-for-a-library
+
+logging.getLogger("charset_normalizer").addHandler(logging.NullHandler())
diff --git a/python/user_packages/Python313/site-packages/charset_normalizer/__main__.py b/python/user_packages/Python313/site-packages/charset_normalizer/__main__.py
new file mode 100644
index 0000000000000000000000000000000000000000..7b623edfde51fc72f586702ed8b5c2f742cfe059
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/charset_normalizer/__main__.py
@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+from .cli import cli_detect
+
+if __name__ == "__main__":
+ cli_detect()
diff --git a/python/user_packages/Python313/site-packages/charset_normalizer/api.py b/python/user_packages/Python313/site-packages/charset_normalizer/api.py
new file mode 100644
index 0000000000000000000000000000000000000000..ddfba32b58b93c3a61332799f6b85da59838e796
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/charset_normalizer/api.py
@@ -0,0 +1,988 @@
+from __future__ import annotations
+
+import logging
+from os import PathLike
+from typing import BinaryIO
+
+from .cd import (
+ coherence_ratio,
+ encoding_languages,
+ mb_encoding_languages,
+ merge_coherence_ratios,
+)
+from .constant import (
+ IANA_SUPPORTED,
+ IANA_SUPPORTED_SIMILAR,
+ TOO_BIG_SEQUENCE,
+ TOO_SMALL_SEQUENCE,
+ TRACE,
+)
+from .md import mess_ratio
+from .models import CharsetMatch, CharsetMatches
+from .utils import (
+ any_specified_encoding,
+ cut_sequence_chunks,
+ iana_name,
+ identify_sig_or_bom,
+ is_multi_byte_encoding,
+ should_strip_sig_or_bom,
+)
+
+logger = logging.getLogger("charset_normalizer")
+explain_handler = logging.StreamHandler()
+explain_handler.setFormatter(
+ logging.Formatter("%(asctime)s | %(levelname)s | %(message)s")
+)
+
+# Pre-compute a reordered encoding list: multibyte first, then single-byte.
+# This allows the mb_definitive_match optimization to fire earlier, skipping
+# all single-byte encodings for genuine CJK content. Multibyte codecs
+# hard-fail (UnicodeDecodeError) on single-byte data almost instantly, so
+# testing them first costs negligible time for non-CJK files.
+_mb_supported: list[str] = []
+_sb_supported: list[str] = []
+
+for _supported_enc in IANA_SUPPORTED:
+ try:
+ if is_multi_byte_encoding(_supported_enc):
+ _mb_supported.append(_supported_enc)
+ else:
+ _sb_supported.append(_supported_enc)
+ except ImportError:
+ _sb_supported.append(_supported_enc)
+
+IANA_SUPPORTED_MB_FIRST: list[str] = _mb_supported + _sb_supported
+
+
+def from_bytes(
+ sequences: bytes | bytearray,
+ steps: int = 5,
+ chunk_size: int = 512,
+ threshold: float = 0.2,
+ cp_isolation: list[str] | None = None,
+ cp_exclusion: list[str] | None = None,
+ preemptive_behaviour: bool = True,
+ explain: bool = False,
+ language_threshold: float = 0.1,
+ enable_fallback: bool = True,
+) -> CharsetMatches:
+ """
+ Given a raw bytes sequence, return the best possibles charset usable to render str objects.
+ If there is no results, it is a strong indicator that the source is binary/not text.
+ By default, the process will extract 5 blocks of 512o each to assess the mess and coherence of a given sequence.
+ And will give up a particular code page after 20% of measured mess. Those criteria are customizable at will.
+
+ The preemptive behavior DOES NOT replace the traditional detection workflow, it prioritize a particular code page
+ but never take it for granted. Can improve the performance.
+
+ You may want to focus your attention to some code page or/and not others, use cp_isolation and cp_exclusion for that
+ purpose.
+
+ This function will strip the SIG in the payload/sequence every time except on UTF-16, UTF-32.
+ By default the library does not setup any handler other than the NullHandler, if you choose to set the 'explain'
+ toggle to True it will alter the logger configuration to add a StreamHandler that is suitable for debugging.
+ Custom logging format and handler can be set manually.
+ """
+
+ if not isinstance(sequences, (bytearray, bytes)):
+ raise TypeError(
+ "Expected object of type bytes or bytearray, got: {}".format(
+ type(sequences)
+ )
+ )
+
+ if explain:
+ previous_logger_level: int = logger.level
+ logger.addHandler(explain_handler)
+ logger.setLevel(TRACE)
+
+ length: int = len(sequences)
+
+ if length == 0:
+ logger.debug("Encoding detection on empty bytes, assuming utf_8 intention.")
+ if explain: # Defensive: ensure exit path clean handler
+ logger.removeHandler(explain_handler)
+ logger.setLevel(previous_logger_level)
+ return CharsetMatches([CharsetMatch(sequences, "utf_8", 0.0, False, [], "")])
+
+ if cp_isolation is not None:
+ logger.log(
+ TRACE,
+ "cp_isolation is set. use this flag for debugging purpose. "
+ "limited list of encoding allowed : %s.",
+ ", ".join(cp_isolation),
+ )
+ cp_isolation = [iana_name(cp, False) for cp in cp_isolation]
+ else:
+ cp_isolation = []
+
+ if cp_exclusion is not None:
+ logger.log(
+ TRACE,
+ "cp_exclusion is set. use this flag for debugging purpose. "
+ "limited list of encoding excluded : %s.",
+ ", ".join(cp_exclusion),
+ )
+ cp_exclusion = [iana_name(cp, False) for cp in cp_exclusion]
+ else:
+ cp_exclusion = []
+
+ if length <= (chunk_size * steps):
+ logger.log(
+ TRACE,
+ "override steps (%i) and chunk_size (%i) as content does not fit (%i byte(s) given) parameters.",
+ steps,
+ chunk_size,
+ length,
+ )
+ steps = 1
+ chunk_size = length
+
+ if steps > 1 and length / steps < chunk_size:
+ chunk_size = int(length / steps)
+
+ is_too_small_sequence: bool = len(sequences) < TOO_SMALL_SEQUENCE
+ is_too_large_sequence: bool = len(sequences) >= TOO_BIG_SEQUENCE
+
+ if is_too_small_sequence:
+ logger.log(
+ TRACE,
+ "Trying to detect encoding from a tiny portion of ({}) byte(s).".format(
+ length
+ ),
+ )
+ elif is_too_large_sequence:
+ logger.log(
+ TRACE,
+ "Using lazy str decoding because the payload is quite large, ({}) byte(s).".format(
+ length
+ ),
+ )
+
+ prioritized_encodings: list[str] = []
+
+ specified_encoding: str | None = (
+ any_specified_encoding(sequences) if preemptive_behaviour else None
+ )
+
+ if specified_encoding is not None:
+ prioritized_encodings.append(specified_encoding)
+ logger.log(
+ TRACE,
+ "Detected declarative mark in sequence. Priority +1 given for %s.",
+ specified_encoding,
+ )
+
+ tested: set[str] = set()
+ tested_but_hard_failure: list[str] = []
+ tested_but_soft_failure: list[str] = []
+ soft_failure_skip: set[str] = set()
+ success_fast_tracked: set[str] = set()
+
+ # Cache for decoded payload deduplication: hash(decoded_payload) -> (mean_mess_ratio, cd_ratios_merged, passed)
+ # When multiple encodings decode to the exact same string, we can skip the expensive
+ # mess_ratio and coherence_ratio analysis and reuse the results from the first encoding.
+ payload_result_cache: dict[int, tuple[float, list[tuple[str, float]], bool]] = {}
+
+ # When a definitive result (chaos=0.0 and good coherence) is found after testing
+ # the prioritized encodings (ascii, utf_8), we can significantly reduce the remaining
+ # work. Encodings that target completely different language families (e.g., Cyrillic
+ # when the definitive match is Latin) are skipped entirely.
+ # Additionally, for same-family encodings that pass chaos probing, we reuse the
+ # definitive match's coherence ratios instead of recomputing them — a major savings
+ # since coherence_ratio accounts for ~30% of total time on slow Latin files.
+ definitive_match_found: bool = False
+ definitive_target_languages: set[str] = set()
+ # After the definitive match fires, we cap the number of additional same-family
+ # single-byte encodings that pass chaos probing. Once we've accumulated enough
+ # good candidates (N), further same-family SB encodings are unlikely to produce
+ # a better best() result and just waste mess_ratio + coherence_ratio time.
+ # The first encoding to trigger the definitive match is NOT counted (it's already in).
+ post_definitive_sb_success_count: int = 0
+ POST_DEFINITIVE_SB_CAP: int = 7
+
+ # When a non-UTF multibyte encoding passes chaos probing with significant multibyte
+ # content (decoded length < 98% of raw length), skip all remaining single-byte encodings.
+ # Rationale: multi-byte decoders (CJK) have strict byte-sequence validation — if they
+ # decode without error AND pass chaos probing with substantial multibyte content, the
+ # data is genuinely multibyte encoded. Single-byte encodings will always decode (every
+ # byte maps to something) but waste time on mess_ratio before failing.
+ # The 98% threshold prevents false triggers on files that happen to have a few valid
+ # multibyte pairs (e.g., cp424/_ude_1.txt where big5 decodes with 99% ratio).
+ mb_definitive_match_found: bool = False
+
+ fallback_ascii: CharsetMatch | None = None
+ fallback_u8: CharsetMatch | None = None
+ fallback_specified: CharsetMatch | None = None
+
+ results: CharsetMatches = CharsetMatches()
+
+ early_stop_results: CharsetMatches = CharsetMatches()
+
+ sig_encoding, sig_payload = identify_sig_or_bom(sequences)
+
+ if sig_encoding is not None:
+ prioritized_encodings.append(sig_encoding)
+ logger.log(
+ TRACE,
+ "Detected a SIG or BOM mark on first %i byte(s). Priority +1 given for %s.",
+ len(sig_payload),
+ sig_encoding,
+ )
+
+ prioritized_encodings.append("ascii")
+
+ if "utf_8" not in prioritized_encodings:
+ prioritized_encodings.append("utf_8")
+
+ for encoding_iana in prioritized_encodings + IANA_SUPPORTED_MB_FIRST:
+ if cp_isolation and encoding_iana not in cp_isolation:
+ continue
+
+ if cp_exclusion and encoding_iana in cp_exclusion:
+ continue
+
+ if encoding_iana in tested:
+ continue
+
+ tested.add(encoding_iana)
+
+ decoded_payload: str | None = None
+ bom_or_sig_available: bool = sig_encoding == encoding_iana
+ strip_sig_or_bom: bool = bom_or_sig_available and should_strip_sig_or_bom(
+ encoding_iana
+ )
+
+ if encoding_iana in {"utf_16", "utf_32"} and not bom_or_sig_available:
+ logger.log(
+ TRACE,
+ "Encoding %s won't be tested as-is because it require a BOM. Will try some sub-encoder LE/BE.",
+ encoding_iana,
+ )
+ continue
+ if encoding_iana in {"utf_7"} and not bom_or_sig_available:
+ logger.log(
+ TRACE,
+ "Encoding %s won't be tested as-is because detection is unreliable without BOM/SIG.",
+ encoding_iana,
+ )
+ continue
+
+ # Skip encodings similar to ones that already soft-failed (high mess ratio).
+ # Checked BEFORE the expensive decode attempt.
+ if encoding_iana in soft_failure_skip:
+ logger.log(
+ TRACE,
+ "%s is deemed too similar to a code page that was already considered unsuited. Continuing!",
+ encoding_iana,
+ )
+ continue
+
+ # Skip encodings that were already fast-tracked from a similar successful encoding.
+ if encoding_iana in success_fast_tracked:
+ logger.log(
+ TRACE,
+ "Skipping %s: already fast-tracked from a similar successful encoding.",
+ encoding_iana,
+ )
+ continue
+
+ try:
+ is_multi_byte_decoder: bool = is_multi_byte_encoding(encoding_iana)
+ except (ModuleNotFoundError, ImportError): # Defensive:
+ logger.log(
+ TRACE,
+ "Encoding %s does not provide an IncrementalDecoder",
+ encoding_iana,
+ )
+ continue
+
+ # When we've already found a definitive match (chaos=0.0 with good coherence)
+ # after testing the prioritized encodings, skip encodings that target
+ # completely different language families. This avoids running expensive
+ # mess_ratio + coherence_ratio on clearly unrelated candidates (e.g., Cyrillic
+ # when the definitive match is Latin-based).
+ if definitive_match_found:
+ if not is_multi_byte_decoder:
+ enc_languages = set(encoding_languages(encoding_iana))
+ else:
+ enc_languages = set(mb_encoding_languages(encoding_iana))
+ if not enc_languages.intersection(definitive_target_languages):
+ logger.log(
+ TRACE,
+ "Skipping %s: definitive match already found, this encoding targets different languages (%s vs %s).",
+ encoding_iana,
+ enc_languages,
+ definitive_target_languages,
+ )
+ continue
+
+ # After the definitive match, cap the number of additional same-family
+ # single-byte encodings that pass chaos probing. This avoids testing the
+ # tail of rare, low-value same-family encodings (mac_iceland, cp860, etc.)
+ # that almost never change best() but each cost ~1-2ms of mess_ratio + coherence.
+ if (
+ definitive_match_found
+ and not is_multi_byte_decoder
+ and post_definitive_sb_success_count >= POST_DEFINITIVE_SB_CAP
+ ):
+ logger.log(
+ TRACE,
+ "Skipping %s: already accumulated %d same-family results after definitive match (cap=%d).",
+ encoding_iana,
+ post_definitive_sb_success_count,
+ POST_DEFINITIVE_SB_CAP,
+ )
+ continue
+
+ # When a multibyte encoding with significant multibyte content has already
+ # passed chaos probing, skip all single-byte encodings. They will either fail
+ # chaos probing (wasting mess_ratio time) or produce inferior results.
+ if mb_definitive_match_found and not is_multi_byte_decoder:
+ logger.log(
+ TRACE,
+ "Skipping single-byte %s: multi-byte definitive match already found.",
+ encoding_iana,
+ )
+ continue
+
+ try:
+ if is_too_large_sequence and is_multi_byte_decoder is False:
+ str(
+ (
+ sequences[: int(50e4)]
+ if strip_sig_or_bom is False
+ else sequences[len(sig_payload) : int(50e4)]
+ ),
+ encoding=encoding_iana,
+ )
+ else:
+ # UTF-7 BOM is encoded in modified Base64 whose byte boundary
+ # can overlap with the next character. Stripping raw SIG bytes
+ # before decoding may leave stray bytes that decode as garbage.
+ # Decode the full sequence and remove the leading BOM char instead.
+ # see https://github.com/jawah/charset_normalizer/issues/718
+ # and https://github.com/jawah/charset_normalizer/issues/716
+ if encoding_iana == "utf_7" and bom_or_sig_available:
+ decoded_payload = str(
+ sequences,
+ encoding=encoding_iana,
+ )
+ if decoded_payload and decoded_payload[0] == "\ufeff":
+ decoded_payload = decoded_payload[1:]
+ else:
+ decoded_payload = str(
+ (
+ sequences
+ if strip_sig_or_bom is False
+ else sequences[len(sig_payload) :]
+ ),
+ encoding=encoding_iana,
+ )
+ except (UnicodeDecodeError, LookupError) as e:
+ if not isinstance(e, LookupError):
+ logger.log(
+ TRACE,
+ "Code page %s does not fit given bytes sequence at ALL. %s",
+ encoding_iana,
+ str(e),
+ )
+ tested_but_hard_failure.append(encoding_iana)
+ continue
+
+ r_ = range(
+ 0 if not bom_or_sig_available else len(sig_payload),
+ length,
+ int(length / steps),
+ )
+
+ multi_byte_bonus: bool = (
+ is_multi_byte_decoder
+ and decoded_payload is not None
+ and len(decoded_payload) < length
+ )
+
+ if multi_byte_bonus:
+ logger.log(
+ TRACE,
+ "Code page %s is a multi byte encoding table and it appear that at least one character "
+ "was encoded using n-bytes.",
+ encoding_iana,
+ )
+
+ # Payload-hash deduplication: if another encoding already decoded to the
+ # exact same string, reuse its mess_ratio and coherence results entirely.
+ # This is strictly more general than the old IANA_SUPPORTED_SIMILAR approach
+ # because it catches ALL identical decoding, not just pre-mapped ones.
+ if decoded_payload is not None and not is_multi_byte_decoder:
+ payload_hash: int = hash(decoded_payload)
+ cached = payload_result_cache.get(payload_hash)
+ if cached is not None:
+ cached_mess, cached_cd, cached_passed = cached
+ if cached_passed:
+ # The previous encoding with identical output passed chaos probing.
+ fast_match = CharsetMatch(
+ sequences,
+ encoding_iana,
+ cached_mess,
+ bom_or_sig_available,
+ cached_cd,
+ (
+ decoded_payload
+ if (
+ is_too_large_sequence is False
+ or encoding_iana
+ in [specified_encoding, "ascii", "utf_8"]
+ )
+ else None
+ ),
+ preemptive_declaration=specified_encoding,
+ )
+ results.append(fast_match)
+ success_fast_tracked.add(encoding_iana)
+ logger.log(
+ TRACE,
+ "%s fast-tracked (identical decoded payload to a prior encoding, chaos=%f %%).",
+ encoding_iana,
+ round(cached_mess * 100, ndigits=3),
+ )
+
+ if (
+ encoding_iana in [specified_encoding, "ascii", "utf_8"]
+ and cached_mess < 0.1
+ ):
+ if cached_mess == 0.0:
+ logger.debug(
+ "Encoding detection: %s is most likely the one.",
+ fast_match.encoding,
+ )
+ if explain:
+ logger.removeHandler(explain_handler)
+ logger.setLevel(previous_logger_level)
+ return CharsetMatches([fast_match])
+ early_stop_results.append(fast_match)
+
+ if (
+ len(early_stop_results)
+ and (specified_encoding is None or specified_encoding in tested)
+ and "ascii" in tested
+ and "utf_8" in tested
+ ):
+ probable_result: CharsetMatch = early_stop_results.best() # type: ignore[assignment]
+ logger.debug(
+ "Encoding detection: %s is most likely the one.",
+ probable_result.encoding,
+ )
+ if explain:
+ logger.removeHandler(explain_handler)
+ logger.setLevel(previous_logger_level)
+ return CharsetMatches([probable_result])
+
+ continue
+ else:
+ # The previous encoding with identical output failed chaos probing.
+ tested_but_soft_failure.append(encoding_iana)
+ logger.log(
+ TRACE,
+ "%s fast-skipped (identical decoded payload to a prior encoding that failed chaos probing).",
+ encoding_iana,
+ )
+ # Prepare fallbacks for special encodings even when skipped.
+ if enable_fallback and encoding_iana in [
+ "ascii",
+ "utf_8",
+ specified_encoding,
+ "utf_16",
+ "utf_32",
+ ]:
+ fallback_entry = CharsetMatch(
+ sequences,
+ encoding_iana,
+ threshold,
+ bom_or_sig_available,
+ [],
+ decoded_payload,
+ preemptive_declaration=specified_encoding,
+ )
+ if encoding_iana == specified_encoding:
+ fallback_specified = fallback_entry
+ elif encoding_iana == "ascii":
+ fallback_ascii = fallback_entry
+ else:
+ fallback_u8 = fallback_entry
+ continue
+
+ max_chunk_gave_up: int = int(len(r_) / 4)
+
+ max_chunk_gave_up = max(max_chunk_gave_up, 2)
+ early_stop_count: int = 0
+ lazy_str_hard_failure = False
+
+ md_chunks: list[str] = []
+ md_ratios = []
+
+ try:
+ for chunk in cut_sequence_chunks(
+ sequences,
+ encoding_iana,
+ r_,
+ chunk_size,
+ bom_or_sig_available,
+ strip_sig_or_bom,
+ sig_payload,
+ is_multi_byte_decoder,
+ decoded_payload,
+ ):
+ md_chunks.append(chunk)
+
+ md_ratios.append(
+ mess_ratio(
+ chunk,
+ threshold,
+ explain is True and 1 <= len(cp_isolation) <= 2,
+ )
+ )
+
+ if md_ratios[-1] >= threshold:
+ early_stop_count += 1
+
+ if (early_stop_count >= max_chunk_gave_up) or (
+ bom_or_sig_available and strip_sig_or_bom is False
+ ):
+ break
+ except (
+ UnicodeDecodeError
+ ) as e: # Lazy str loading may have missed something there
+ logger.log(
+ TRACE,
+ "LazyStr Loading: After MD chunk decode, code page %s does not fit given bytes sequence at ALL. %s",
+ encoding_iana,
+ str(e),
+ )
+ early_stop_count = max_chunk_gave_up
+ lazy_str_hard_failure = True
+
+ # We might want to check the sequence again with the whole content
+ # Only if initial MD tests passes
+ if (
+ not lazy_str_hard_failure
+ and is_too_large_sequence
+ and not is_multi_byte_decoder
+ ):
+ try:
+ sequences[int(50e3) :].decode(encoding_iana, errors="strict")
+ except UnicodeDecodeError as e:
+ logger.log(
+ TRACE,
+ "LazyStr Loading: After final lookup, code page %s does not fit given bytes sequence at ALL. %s",
+ encoding_iana,
+ str(e),
+ )
+ tested_but_hard_failure.append(encoding_iana)
+ continue
+
+ mean_mess_ratio: float = sum(md_ratios) / len(md_ratios) if md_ratios else 0.0
+ if mean_mess_ratio >= threshold or early_stop_count >= max_chunk_gave_up:
+ tested_but_soft_failure.append(encoding_iana)
+ if encoding_iana in IANA_SUPPORTED_SIMILAR:
+ soft_failure_skip.update(IANA_SUPPORTED_SIMILAR[encoding_iana])
+ # Cache this soft-failure so identical decoding from other encodings
+ # can be skipped immediately.
+ if decoded_payload is not None and not is_multi_byte_decoder:
+ payload_result_cache.setdefault(
+ hash(decoded_payload), (mean_mess_ratio, [], False)
+ )
+ logger.log(
+ TRACE,
+ "%s was excluded because of initial chaos probing. Gave up %i time(s). "
+ "Computed mean chaos is %f %%.",
+ encoding_iana,
+ early_stop_count,
+ round(mean_mess_ratio * 100, ndigits=3),
+ )
+ # Preparing those fallbacks in case we got nothing.
+ if (
+ enable_fallback
+ and encoding_iana
+ in ["ascii", "utf_8", specified_encoding, "utf_16", "utf_32"]
+ and not lazy_str_hard_failure
+ ):
+ fallback_entry = CharsetMatch(
+ sequences,
+ encoding_iana,
+ threshold,
+ bom_or_sig_available,
+ [],
+ decoded_payload,
+ preemptive_declaration=specified_encoding,
+ )
+ if encoding_iana == specified_encoding:
+ fallback_specified = fallback_entry
+ elif encoding_iana == "ascii":
+ fallback_ascii = fallback_entry
+ else:
+ fallback_u8 = fallback_entry
+ continue
+
+ logger.log(
+ TRACE,
+ "%s passed initial chaos probing. Mean measured chaos is %f %%",
+ encoding_iana,
+ round(mean_mess_ratio * 100, ndigits=3),
+ )
+
+ if not is_multi_byte_decoder:
+ target_languages: list[str] = encoding_languages(encoding_iana)
+ else:
+ target_languages = mb_encoding_languages(encoding_iana)
+
+ if target_languages:
+ logger.log(
+ TRACE,
+ "{} should target any language(s) of {}".format(
+ encoding_iana, str(target_languages)
+ ),
+ )
+
+ cd_ratios = []
+
+ # Run coherence detection on all chunks. We previously tried limiting to
+ # 1-2 chunks for post-definitive encodings to save time, but this caused
+ # coverage regressions by producing unrepresentative coherence scores.
+ # The SB cap and language-family skip optimizations provide sufficient
+ # speedup without sacrificing coherence accuracy.
+ if encoding_iana != "ascii":
+ # We shall skip the CD when its about ASCII
+ # Most of the time its not relevant to run "language-detection" on it.
+ for chunk in md_chunks:
+ chunk_languages = coherence_ratio(
+ chunk,
+ language_threshold,
+ ",".join(target_languages) if target_languages else None,
+ )
+
+ cd_ratios.append(chunk_languages)
+ cd_ratios_merged = merge_coherence_ratios(cd_ratios)
+ else:
+ cd_ratios_merged = merge_coherence_ratios(cd_ratios)
+
+ if cd_ratios_merged:
+ logger.log(
+ TRACE,
+ "We detected language {} using {}".format(
+ cd_ratios_merged, encoding_iana
+ ),
+ )
+
+ current_match = CharsetMatch(
+ sequences,
+ encoding_iana,
+ mean_mess_ratio,
+ bom_or_sig_available,
+ cd_ratios_merged,
+ (
+ decoded_payload
+ if (
+ is_too_large_sequence is False
+ or encoding_iana in [specified_encoding, "ascii", "utf_8"]
+ )
+ else None
+ ),
+ preemptive_declaration=specified_encoding,
+ )
+
+ results.append(current_match)
+
+ # Cache the successful result for payload-hash deduplication.
+ if decoded_payload is not None and not is_multi_byte_decoder:
+ payload_result_cache.setdefault(
+ hash(decoded_payload),
+ (mean_mess_ratio, cd_ratios_merged, True),
+ )
+
+ # Count post-definitive same-family SB successes for the early termination cap.
+ # Only count low-mess encodings (< 2%) toward the cap. High-mess encodings are
+ # marginal results that shouldn't prevent better-quality candidates from being
+ # tested. For example, iso8859_4 (mess=0%) should not be skipped just because
+ # 7 high-mess Latin encodings (cp1252 at 8%, etc.) were tried first.
+ if (
+ definitive_match_found
+ and not is_multi_byte_decoder
+ and mean_mess_ratio < 0.02
+ ):
+ post_definitive_sb_success_count += 1
+
+ if (
+ encoding_iana in [specified_encoding, "ascii", "utf_8"]
+ and mean_mess_ratio < 0.1
+ ):
+ # If md says nothing to worry about, then... stop immediately!
+ if mean_mess_ratio == 0.0:
+ logger.debug(
+ "Encoding detection: %s is most likely the one.",
+ current_match.encoding,
+ )
+ if explain: # Defensive: ensure exit path clean handler
+ logger.removeHandler(explain_handler)
+ logger.setLevel(previous_logger_level)
+ return CharsetMatches([current_match])
+
+ early_stop_results.append(current_match)
+
+ if (
+ len(early_stop_results)
+ and (specified_encoding is None or specified_encoding in tested)
+ and "ascii" in tested
+ and "utf_8" in tested
+ ):
+ probable_result = early_stop_results.best() # type: ignore[assignment]
+ logger.debug(
+ "Encoding detection: %s is most likely the one.",
+ probable_result.encoding, # type: ignore[union-attr]
+ )
+ if explain: # Defensive: ensure exit path clean handler
+ logger.removeHandler(explain_handler)
+ logger.setLevel(previous_logger_level)
+
+ return CharsetMatches([probable_result])
+
+ # Once we find a result with good coherence (>= 0.5) after testing the
+ # prioritized encodings (ascii, utf_8), activate "definitive mode": skip
+ # encodings that target completely different language families. This avoids
+ # running expensive mess_ratio + coherence_ratio on clearly unrelated
+ # candidates (e.g., Cyrillic encodings when the match is Latin-based).
+ # We require coherence >= 0.5 to avoid false positives (e.g., cp1251 decoding
+ # Hebrew text with 0.0 chaos but wrong language detection at coherence 0.33).
+ if not definitive_match_found and not is_multi_byte_decoder:
+ best_coherence = (
+ max((v for _, v in cd_ratios_merged), default=0.0)
+ if cd_ratios_merged
+ else 0.0
+ )
+ if best_coherence >= 0.5 and "ascii" in tested and "utf_8" in tested:
+ definitive_match_found = True
+ definitive_target_languages.update(target_languages)
+ logger.log(
+ TRACE,
+ "Definitive match found: %s (chaos=%.3f, coherence=%.2f). Encodings targeting different language families will be skipped.",
+ encoding_iana,
+ mean_mess_ratio,
+ best_coherence,
+ )
+
+ # When a non-UTF multibyte encoding passes chaos probing with significant
+ # multibyte content (decoded < 98% of raw), activate mb_definitive_match.
+ # This skips all remaining single-byte encodings which would either soft-fail
+ # (running expensive mess_ratio for nothing) or produce inferior results.
+ if (
+ not mb_definitive_match_found
+ and is_multi_byte_decoder
+ and multi_byte_bonus
+ and decoded_payload is not None
+ and len(decoded_payload) < length * 0.98
+ and encoding_iana
+ not in {
+ "utf_8",
+ "utf_8_sig",
+ "utf_16",
+ "utf_16_be",
+ "utf_16_le",
+ "utf_32",
+ "utf_32_be",
+ "utf_32_le",
+ "utf_7",
+ }
+ and "ascii" in tested
+ and "utf_8" in tested
+ ):
+ mb_definitive_match_found = True
+ logger.log(
+ TRACE,
+ "Multi-byte definitive match: %s (chaos=%.3f, decoded=%d/%d=%.1f%%). Single-byte encodings will be skipped.",
+ encoding_iana,
+ mean_mess_ratio,
+ len(decoded_payload),
+ length,
+ len(decoded_payload) / length * 100,
+ )
+
+ if encoding_iana == sig_encoding:
+ logger.debug(
+ "Encoding detection: %s is most likely the one as we detected a BOM or SIG within "
+ "the beginning of the sequence.",
+ encoding_iana,
+ )
+ if explain: # Defensive: ensure exit path clean handler
+ logger.removeHandler(explain_handler)
+ logger.setLevel(previous_logger_level)
+ return CharsetMatches([results[encoding_iana]])
+
+ if len(results) == 0:
+ if fallback_u8 or fallback_ascii or fallback_specified:
+ logger.log(
+ TRACE,
+ "Nothing got out of the detection process. Using ASCII/UTF-8/Specified fallback.",
+ )
+
+ if fallback_specified:
+ logger.debug(
+ "Encoding detection: %s will be used as a fallback match",
+ fallback_specified.encoding,
+ )
+ results.append(fallback_specified)
+ elif (
+ (fallback_u8 and fallback_ascii is None)
+ or (
+ fallback_u8
+ and fallback_ascii
+ and fallback_u8.fingerprint != fallback_ascii.fingerprint
+ )
+ or (fallback_u8 is not None)
+ ):
+ logger.debug("Encoding detection: utf_8 will be used as a fallback match")
+ results.append(fallback_u8)
+ elif fallback_ascii:
+ logger.debug("Encoding detection: ascii will be used as a fallback match")
+ results.append(fallback_ascii)
+
+ if results:
+ logger.debug(
+ "Encoding detection: Found %s as plausible (best-candidate) for content. With %i alternatives.",
+ results.best().encoding, # type: ignore
+ len(results) - 1,
+ )
+ else:
+ logger.debug("Encoding detection: Unable to determine any suitable charset.")
+
+ if explain:
+ logger.removeHandler(explain_handler)
+ logger.setLevel(previous_logger_level)
+
+ return results
+
+
+def from_fp(
+ fp: BinaryIO,
+ steps: int = 5,
+ chunk_size: int = 512,
+ threshold: float = 0.20,
+ cp_isolation: list[str] | None = None,
+ cp_exclusion: list[str] | None = None,
+ preemptive_behaviour: bool = True,
+ explain: bool = False,
+ language_threshold: float = 0.1,
+ enable_fallback: bool = True,
+) -> CharsetMatches:
+ """
+ Same thing than the function from_bytes but using a file pointer that is already ready.
+ Will not close the file pointer.
+ """
+ return from_bytes(
+ fp.read(),
+ steps,
+ chunk_size,
+ threshold,
+ cp_isolation,
+ cp_exclusion,
+ preemptive_behaviour,
+ explain,
+ language_threshold,
+ enable_fallback,
+ )
+
+
+def from_path(
+ path: str | bytes | PathLike, # type: ignore[type-arg]
+ steps: int = 5,
+ chunk_size: int = 512,
+ threshold: float = 0.20,
+ cp_isolation: list[str] | None = None,
+ cp_exclusion: list[str] | None = None,
+ preemptive_behaviour: bool = True,
+ explain: bool = False,
+ language_threshold: float = 0.1,
+ enable_fallback: bool = True,
+) -> CharsetMatches:
+ """
+ Same thing than the function from_bytes but with one extra step. Opening and reading given file path in binary mode.
+ Can raise IOError.
+ """
+ with open(path, "rb") as fp:
+ return from_fp(
+ fp,
+ steps,
+ chunk_size,
+ threshold,
+ cp_isolation,
+ cp_exclusion,
+ preemptive_behaviour,
+ explain,
+ language_threshold,
+ enable_fallback,
+ )
+
+
+def is_binary(
+ fp_or_path_or_payload: PathLike | str | BinaryIO | bytes, # type: ignore[type-arg]
+ steps: int = 5,
+ chunk_size: int = 512,
+ threshold: float = 0.20,
+ cp_isolation: list[str] | None = None,
+ cp_exclusion: list[str] | None = None,
+ preemptive_behaviour: bool = True,
+ explain: bool = False,
+ language_threshold: float = 0.1,
+ enable_fallback: bool = False,
+) -> bool:
+ """
+ Detect if the given input (file, bytes, or path) points to a binary file. aka. not a string.
+ Based on the same main heuristic algorithms and default kwargs at the sole exception that fallbacks match
+ are disabled to be stricter around ASCII-compatible but unlikely to be a string.
+ """
+ if isinstance(fp_or_path_or_payload, (str, PathLike)):
+ guesses = from_path(
+ fp_or_path_or_payload,
+ steps=steps,
+ chunk_size=chunk_size,
+ threshold=threshold,
+ cp_isolation=cp_isolation,
+ cp_exclusion=cp_exclusion,
+ preemptive_behaviour=preemptive_behaviour,
+ explain=explain,
+ language_threshold=language_threshold,
+ enable_fallback=enable_fallback,
+ )
+ elif isinstance(
+ fp_or_path_or_payload,
+ (
+ bytes,
+ bytearray,
+ ),
+ ):
+ guesses = from_bytes(
+ fp_or_path_or_payload,
+ steps=steps,
+ chunk_size=chunk_size,
+ threshold=threshold,
+ cp_isolation=cp_isolation,
+ cp_exclusion=cp_exclusion,
+ preemptive_behaviour=preemptive_behaviour,
+ explain=explain,
+ language_threshold=language_threshold,
+ enable_fallback=enable_fallback,
+ )
+ else:
+ guesses = from_fp(
+ fp_or_path_or_payload,
+ steps=steps,
+ chunk_size=chunk_size,
+ threshold=threshold,
+ cp_isolation=cp_isolation,
+ cp_exclusion=cp_exclusion,
+ preemptive_behaviour=preemptive_behaviour,
+ explain=explain,
+ language_threshold=language_threshold,
+ enable_fallback=enable_fallback,
+ )
+
+ return not guesses
diff --git a/python/user_packages/Python313/site-packages/charset_normalizer/cd.cp313-win_amd64.pyd b/python/user_packages/Python313/site-packages/charset_normalizer/cd.cp313-win_amd64.pyd
new file mode 100644
index 0000000000000000000000000000000000000000..1a42548d943061367b4dd9c20ddde58f98bca566
Binary files /dev/null and b/python/user_packages/Python313/site-packages/charset_normalizer/cd.cp313-win_amd64.pyd differ
diff --git a/python/user_packages/Python313/site-packages/charset_normalizer/cd.py b/python/user_packages/Python313/site-packages/charset_normalizer/cd.py
new file mode 100644
index 0000000000000000000000000000000000000000..657a2209b1c93980c5f6fd8f5bf43bf27091cbb3
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/charset_normalizer/cd.py
@@ -0,0 +1,454 @@
+from __future__ import annotations
+
+import importlib
+from codecs import IncrementalDecoder
+from collections import Counter
+from functools import lru_cache
+from typing import Counter as TypeCounter
+
+from .constant import (
+ FREQUENCIES,
+ KO_NAMES,
+ LANGUAGE_SUPPORTED_COUNT,
+ TOO_SMALL_SEQUENCE,
+ ZH_NAMES,
+ _FREQUENCIES_SET,
+ _FREQUENCIES_RANK,
+)
+from .md import is_suspiciously_successive_range
+from .models import CoherenceMatches
+from .utils import (
+ is_accentuated,
+ is_latin,
+ is_multi_byte_encoding,
+ is_unicode_range_secondary,
+ unicode_range,
+)
+
+
+def encoding_unicode_range(iana_name: str) -> list[str]:
+ """
+ Return associated unicode ranges in a single byte code page.
+ """
+ if is_multi_byte_encoding(iana_name):
+ raise OSError( # Defensive:
+ "Function not supported on multi-byte code page"
+ )
+
+ decoder = importlib.import_module(f"encodings.{iana_name}").IncrementalDecoder
+
+ p: IncrementalDecoder = decoder(errors="ignore")
+ seen_ranges: dict[str, int] = {}
+ character_count: int = 0
+
+ for i in range(0x40, 0xFF):
+ chunk: str = p.decode(bytes([i]))
+
+ if chunk:
+ character_range: str | None = unicode_range(chunk)
+
+ if character_range is None:
+ continue
+
+ if is_unicode_range_secondary(character_range) is False:
+ if character_range not in seen_ranges:
+ seen_ranges[character_range] = 0
+ seen_ranges[character_range] += 1
+ character_count += 1
+
+ return sorted(
+ [
+ character_range
+ for character_range in seen_ranges
+ if seen_ranges[character_range] / character_count >= 0.15
+ ]
+ )
+
+
+def unicode_range_languages(primary_range: str) -> list[str]:
+ """
+ Return inferred languages used with a unicode range.
+ """
+ languages: list[str] = []
+
+ for language, characters in FREQUENCIES.items():
+ for character in characters:
+ if unicode_range(character) == primary_range:
+ languages.append(language)
+ break
+
+ return languages
+
+
+@lru_cache()
+def encoding_languages(iana_name: str) -> list[str]:
+ """
+ Single-byte encoding language association. Some code page are heavily linked to particular language(s).
+ This function does the correspondence.
+ """
+ unicode_ranges: list[str] = encoding_unicode_range(iana_name)
+ primary_range: str | None = None
+
+ for specified_range in unicode_ranges:
+ if "Latin" not in specified_range:
+ primary_range = specified_range
+ break
+
+ if primary_range is None:
+ return ["Latin Based"]
+
+ return unicode_range_languages(primary_range)
+
+
+@lru_cache()
+def mb_encoding_languages(iana_name: str) -> list[str]:
+ """
+ Multi-byte encoding language association. Some code page are heavily linked to particular language(s).
+ This function does the correspondence.
+ """
+ if (
+ iana_name.startswith("shift_")
+ or iana_name.startswith("iso2022_jp")
+ or iana_name.startswith("euc_j")
+ or iana_name == "cp932"
+ ):
+ return ["Japanese"]
+ if iana_name.startswith("gb") or iana_name in ZH_NAMES:
+ return ["Chinese"]
+ if iana_name.startswith("iso2022_kr") or iana_name in KO_NAMES:
+ return ["Korean"]
+
+ return []
+
+
+@lru_cache(maxsize=LANGUAGE_SUPPORTED_COUNT)
+def get_target_features(language: str) -> tuple[bool, bool]:
+ """
+ Determine main aspects from a supported language if it contains accents and if is pure Latin.
+ """
+ target_have_accents: bool = False
+ target_pure_latin: bool = True
+
+ for character in FREQUENCIES[language]:
+ if not target_have_accents and is_accentuated(character):
+ target_have_accents = True
+ if target_pure_latin and is_latin(character) is False:
+ target_pure_latin = False
+
+ return target_have_accents, target_pure_latin
+
+
+def alphabet_languages(
+ characters: list[str], ignore_non_latin: bool = False
+) -> list[str]:
+ """
+ Return associated languages associated to given characters.
+ """
+ languages: list[tuple[str, float]] = []
+
+ characters_set: frozenset[str] = frozenset(characters)
+ source_have_accents = any(is_accentuated(character) for character in characters)
+
+ for language, language_characters in FREQUENCIES.items():
+ target_have_accents, target_pure_latin = get_target_features(language)
+
+ if ignore_non_latin and target_pure_latin is False:
+ continue
+
+ if target_have_accents is False and source_have_accents:
+ continue
+
+ character_count: int = len(language_characters)
+
+ character_match_count: int = len(_FREQUENCIES_SET[language] & characters_set)
+
+ ratio: float = character_match_count / character_count
+
+ if ratio >= 0.2:
+ languages.append((language, ratio))
+
+ languages = sorted(languages, key=lambda x: x[1], reverse=True)
+
+ return [compatible_language[0] for compatible_language in languages]
+
+
+def characters_popularity_compare(
+ language: str, ordered_characters: list[str]
+) -> float:
+ """
+ Determine if a ordered characters list (by occurrence from most appearance to rarest) match a particular language.
+ The result is a ratio between 0. (absolutely no correspondence) and 1. (near perfect fit).
+ Beware that is function is not strict on the match in order to ease the detection. (Meaning close match is 1.)
+ """
+ if language not in FREQUENCIES:
+ raise ValueError(f"{language} not available") # Defensive:
+
+ character_approved_count: int = 0
+ frequencies_language_set: frozenset[str] = _FREQUENCIES_SET[language]
+ lang_rank: dict[str, int] = _FREQUENCIES_RANK[language]
+
+ ordered_characters_count: int = len(ordered_characters)
+ target_language_characters_count: int = len(FREQUENCIES[language])
+
+ large_alphabet: bool = target_language_characters_count > 26
+
+ expected_projection_ratio: float = (
+ target_language_characters_count / ordered_characters_count
+ )
+
+ # Pre-built rank dict for ordered_characters (avoids repeated list slicing).
+ ordered_rank: dict[str, int] = {
+ char: rank for rank, char in enumerate(ordered_characters)
+ }
+
+ # Pre-compute characters common to both orderings.
+ # Avoids repeated `c in ordered_rank` dict lookups in the inner counts.
+ common_chars: list[tuple[int, int]] = [
+ (lr, ordered_rank[c]) for c, lr in lang_rank.items() if c in ordered_rank
+ ]
+
+ # Pre-extract lr and orr arrays for faster iteration in the inner loop.
+ # Plain integer loops with local arrays are much faster under mypyc than
+ # generator expression sums over a list of tuples.
+ common_count: int = len(common_chars)
+ common_lr: list[int] = [p[0] for p in common_chars]
+ common_orr: list[int] = [p[1] for p in common_chars]
+
+ for character, character_rank in zip(
+ ordered_characters, range(0, ordered_characters_count)
+ ):
+ if character not in frequencies_language_set:
+ continue
+
+ character_rank_in_language: int = lang_rank[character]
+ character_rank_projection: int = int(character_rank * expected_projection_ratio)
+
+ if (
+ large_alphabet is False
+ and abs(character_rank_projection - character_rank_in_language) > 4
+ ):
+ continue
+
+ if (
+ large_alphabet is True
+ and abs(character_rank_projection - character_rank_in_language)
+ < target_language_characters_count / 3
+ ):
+ character_approved_count += 1
+ continue
+
+ # Count how many characters appear "before" in both orderings,
+ # and how many appear "at or after" in both orderings.
+ # Single pass over pre-extracted arrays — much faster under mypyc
+ # than two generator expression sums.
+ before_match_count: int = 0
+ after_match_count: int = 0
+ for i in range(common_count):
+ lr_i: int = common_lr[i]
+ orr_i: int = common_orr[i]
+ if lr_i < character_rank_in_language:
+ if orr_i < character_rank:
+ before_match_count += 1
+ else:
+ if orr_i >= character_rank:
+ after_match_count += 1
+
+ after_len: int = target_language_characters_count - character_rank_in_language
+
+ if character_rank_in_language == 0 and before_match_count <= 4:
+ character_approved_count += 1
+ continue
+
+ if after_len == 0 and after_match_count <= 4:
+ character_approved_count += 1
+ continue
+
+ if (
+ character_rank_in_language > 0
+ and before_match_count / character_rank_in_language >= 0.4
+ ) or (after_len > 0 and after_match_count / after_len >= 0.4):
+ character_approved_count += 1
+ continue
+
+ return character_approved_count / len(ordered_characters)
+
+
+def alpha_unicode_split(decoded_sequence: str) -> list[str]:
+ """
+ Given a decoded text sequence, return a list of str. Unicode range / alphabet separation.
+ Ex. a text containing English/Latin with a bit a Hebrew will return two items in the resulting list;
+ One containing the latin letters and the other hebrew.
+ """
+ layers: dict[str, list[str]] = {}
+
+ # Fast path: track single-layer key to skip dict iteration for single-script text.
+ single_layer_key: str | None = None
+ multi_layer: bool = False
+
+ # Cache the last character_range and its resolved layer to avoid repeated
+ # is_suspiciously_successive_range calls for consecutive same-range chars.
+ prev_character_range: str | None = None
+ prev_layer_target: str | None = None
+
+ for character in decoded_sequence:
+ if character.isalpha() is False:
+ continue
+
+ # ASCII fast-path: a-z and A-Z are always "Basic Latin".
+ # Avoids unicode_range() function call overhead for the most common case.
+ character_ord: int = ord(character)
+ if character_ord < 128:
+ character_range: str | None = "Basic Latin"
+ else:
+ character_range = unicode_range(character)
+
+ if character_range is None:
+ continue
+
+ # Fast path: same range as previous character → reuse cached layer target.
+ if character_range == prev_character_range:
+ if prev_layer_target is not None:
+ layers[prev_layer_target].append(character)
+ continue
+
+ layer_target_range: str | None = None
+
+ if multi_layer:
+ for discovered_range in layers:
+ if (
+ is_suspiciously_successive_range(discovered_range, character_range)
+ is False
+ ):
+ layer_target_range = discovered_range
+ break
+ elif single_layer_key is not None:
+ if (
+ is_suspiciously_successive_range(single_layer_key, character_range)
+ is False
+ ):
+ layer_target_range = single_layer_key
+
+ if layer_target_range is None:
+ layer_target_range = character_range
+
+ if layer_target_range not in layers:
+ layers[layer_target_range] = []
+ if single_layer_key is None:
+ single_layer_key = layer_target_range
+ else:
+ multi_layer = True
+
+ layers[layer_target_range].append(character)
+
+ # Cache for next iteration
+ prev_character_range = character_range
+ prev_layer_target = layer_target_range
+
+ return ["".join(chars).lower() for chars in layers.values()]
+
+
+def merge_coherence_ratios(results: list[CoherenceMatches]) -> CoherenceMatches:
+ """
+ This function merge results previously given by the function coherence_ratio.
+ The return type is the same as coherence_ratio.
+ """
+ per_language_ratios: dict[str, list[float]] = {}
+ for result in results:
+ for sub_result in result:
+ language, ratio = sub_result
+ if language not in per_language_ratios:
+ per_language_ratios[language] = [ratio]
+ continue
+ per_language_ratios[language].append(ratio)
+
+ merge = [
+ (
+ language,
+ round(
+ sum(per_language_ratios[language]) / len(per_language_ratios[language]),
+ 4,
+ ),
+ )
+ for language in per_language_ratios
+ ]
+
+ return sorted(merge, key=lambda x: x[1], reverse=True)
+
+
+def filter_alt_coherence_matches(results: CoherenceMatches) -> CoherenceMatches:
+ """
+ We shall NOT return "English—" in CoherenceMatches because it is an alternative
+ of "English". This function only keeps the best match and remove the em-dash in it.
+ """
+ index_results: dict[str, list[float]] = dict()
+
+ for result in results:
+ language, ratio = result
+ no_em_name: str = language.replace("—", "")
+
+ if no_em_name not in index_results:
+ index_results[no_em_name] = []
+
+ index_results[no_em_name].append(ratio)
+
+ if any(len(index_results[e]) > 1 for e in index_results):
+ filtered_results: CoherenceMatches = []
+
+ for language in index_results:
+ filtered_results.append((language, max(index_results[language])))
+
+ return filtered_results
+
+ return results
+
+
+@lru_cache(maxsize=2048)
+def coherence_ratio(
+ decoded_sequence: str, threshold: float = 0.1, lg_inclusion: str | None = None
+) -> CoherenceMatches:
+ """
+ Detect ANY language that can be identified in given sequence. The sequence will be analysed by layers.
+ A layer = Character extraction by alphabets/ranges.
+ """
+
+ results: list[tuple[str, float]] = []
+ ignore_non_latin: bool = False
+
+ sufficient_match_count: int = 0
+
+ lg_inclusion_list = lg_inclusion.split(",") if lg_inclusion is not None else []
+ if "Latin Based" in lg_inclusion_list:
+ ignore_non_latin = True
+ lg_inclusion_list.remove("Latin Based")
+
+ for layer in alpha_unicode_split(decoded_sequence):
+ sequence_frequencies: TypeCounter[str] = Counter(layer)
+ most_common = sequence_frequencies.most_common()
+
+ character_count: int = len(layer)
+
+ if character_count <= TOO_SMALL_SEQUENCE:
+ continue
+
+ popular_character_ordered: list[str] = [c for c, o in most_common]
+
+ for language in lg_inclusion_list or alphabet_languages(
+ popular_character_ordered, ignore_non_latin
+ ):
+ ratio: float = characters_popularity_compare(
+ language, popular_character_ordered
+ )
+
+ if ratio < threshold:
+ continue
+ elif ratio >= 0.8:
+ sufficient_match_count += 1
+
+ results.append((language, round(ratio, 4)))
+
+ if sufficient_match_count >= 3:
+ break
+
+ return sorted(
+ filter_alt_coherence_matches(results), key=lambda x: x[1], reverse=True
+ )
diff --git a/python/user_packages/Python313/site-packages/charset_normalizer/constant.py b/python/user_packages/Python313/site-packages/charset_normalizer/constant.py
new file mode 100644
index 0000000000000000000000000000000000000000..7989546b8936db5303e7d2f6ea2da3309bf0fc67
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/charset_normalizer/constant.py
@@ -0,0 +1,2050 @@
+from __future__ import annotations
+
+from codecs import BOM_UTF8, BOM_UTF16_BE, BOM_UTF16_LE, BOM_UTF32_BE, BOM_UTF32_LE
+from encodings.aliases import aliases
+from re import IGNORECASE
+from re import compile as re_compile
+
+# Contain for each eligible encoding a list of/item bytes SIG/BOM
+ENCODING_MARKS: dict[str, bytes | list[bytes]] = {
+ "utf_8": BOM_UTF8,
+ "utf_7": [
+ b"\x2b\x2f\x76\x38\x2d",
+ b"\x2b\x2f\x76\x38",
+ b"\x2b\x2f\x76\x39",
+ b"\x2b\x2f\x76\x2b",
+ b"\x2b\x2f\x76\x2f",
+ ],
+ "gb18030": b"\x84\x31\x95\x33",
+ "utf_32": [BOM_UTF32_BE, BOM_UTF32_LE],
+ "utf_16": [BOM_UTF16_BE, BOM_UTF16_LE],
+}
+
+TOO_SMALL_SEQUENCE: int = 32
+TOO_BIG_SEQUENCE: int = int(10e6)
+
+UTF8_MAXIMAL_ALLOCATION: int = 1_112_064
+
+# Up-to-date Unicode ucd/17.0.0
+UNICODE_RANGES_COMBINED: dict[str, range] = {
+ "Control character": range(32),
+ "Basic Latin": range(32, 128),
+ "Latin-1 Supplement": range(128, 256),
+ "Latin Extended-A": range(256, 384),
+ "Latin Extended-B": range(384, 592),
+ "IPA Extensions": range(592, 688),
+ "Spacing Modifier Letters": range(688, 768),
+ "Combining Diacritical Marks": range(768, 880),
+ "Greek and Coptic": range(880, 1024),
+ "Cyrillic": range(1024, 1280),
+ "Cyrillic Supplement": range(1280, 1328),
+ "Armenian": range(1328, 1424),
+ "Hebrew": range(1424, 1536),
+ "Arabic": range(1536, 1792),
+ "Syriac": range(1792, 1872),
+ "Arabic Supplement": range(1872, 1920),
+ "Thaana": range(1920, 1984),
+ "NKo": range(1984, 2048),
+ "Samaritan": range(2048, 2112),
+ "Mandaic": range(2112, 2144),
+ "Syriac Supplement": range(2144, 2160),
+ "Arabic Extended-B": range(2160, 2208),
+ "Arabic Extended-A": range(2208, 2304),
+ "Devanagari": range(2304, 2432),
+ "Bengali": range(2432, 2560),
+ "Gurmukhi": range(2560, 2688),
+ "Gujarati": range(2688, 2816),
+ "Oriya": range(2816, 2944),
+ "Tamil": range(2944, 3072),
+ "Telugu": range(3072, 3200),
+ "Kannada": range(3200, 3328),
+ "Malayalam": range(3328, 3456),
+ "Sinhala": range(3456, 3584),
+ "Thai": range(3584, 3712),
+ "Lao": range(3712, 3840),
+ "Tibetan": range(3840, 4096),
+ "Myanmar": range(4096, 4256),
+ "Georgian": range(4256, 4352),
+ "Hangul Jamo": range(4352, 4608),
+ "Ethiopic": range(4608, 4992),
+ "Ethiopic Supplement": range(4992, 5024),
+ "Cherokee": range(5024, 5120),
+ "Unified Canadian Aboriginal Syllabics": range(5120, 5760),
+ "Ogham": range(5760, 5792),
+ "Runic": range(5792, 5888),
+ "Tagalog": range(5888, 5920),
+ "Hanunoo": range(5920, 5952),
+ "Buhid": range(5952, 5984),
+ "Tagbanwa": range(5984, 6016),
+ "Khmer": range(6016, 6144),
+ "Mongolian": range(6144, 6320),
+ "Unified Canadian Aboriginal Syllabics Extended": range(6320, 6400),
+ "Limbu": range(6400, 6480),
+ "Tai Le": range(6480, 6528),
+ "New Tai Lue": range(6528, 6624),
+ "Khmer Symbols": range(6624, 6656),
+ "Buginese": range(6656, 6688),
+ "Tai Tham": range(6688, 6832),
+ "Combining Diacritical Marks Extended": range(6832, 6912),
+ "Balinese": range(6912, 7040),
+ "Sundanese": range(7040, 7104),
+ "Batak": range(7104, 7168),
+ "Lepcha": range(7168, 7248),
+ "Ol Chiki": range(7248, 7296),
+ "Cyrillic Extended-C": range(7296, 7312),
+ "Georgian Extended": range(7312, 7360),
+ "Sundanese Supplement": range(7360, 7376),
+ "Vedic Extensions": range(7376, 7424),
+ "Phonetic Extensions": range(7424, 7552),
+ "Phonetic Extensions Supplement": range(7552, 7616),
+ "Combining Diacritical Marks Supplement": range(7616, 7680),
+ "Latin Extended Additional": range(7680, 7936),
+ "Greek Extended": range(7936, 8192),
+ "General Punctuation": range(8192, 8304),
+ "Superscripts and Subscripts": range(8304, 8352),
+ "Currency Symbols": range(8352, 8400),
+ "Combining Diacritical Marks for Symbols": range(8400, 8448),
+ "Letterlike Symbols": range(8448, 8528),
+ "Number Forms": range(8528, 8592),
+ "Arrows": range(8592, 8704),
+ "Mathematical Operators": range(8704, 8960),
+ "Miscellaneous Technical": range(8960, 9216),
+ "Control Pictures": range(9216, 9280),
+ "Optical Character Recognition": range(9280, 9312),
+ "Enclosed Alphanumerics": range(9312, 9472),
+ "Box Drawing": range(9472, 9600),
+ "Block Elements": range(9600, 9632),
+ "Geometric Shapes": range(9632, 9728),
+ "Miscellaneous Symbols": range(9728, 9984),
+ "Dingbats": range(9984, 10176),
+ "Miscellaneous Mathematical Symbols-A": range(10176, 10224),
+ "Supplemental Arrows-A": range(10224, 10240),
+ "Braille Patterns": range(10240, 10496),
+ "Supplemental Arrows-B": range(10496, 10624),
+ "Miscellaneous Mathematical Symbols-B": range(10624, 10752),
+ "Supplemental Mathematical Operators": range(10752, 11008),
+ "Miscellaneous Symbols and Arrows": range(11008, 11264),
+ "Glagolitic": range(11264, 11360),
+ "Latin Extended-C": range(11360, 11392),
+ "Coptic": range(11392, 11520),
+ "Georgian Supplement": range(11520, 11568),
+ "Tifinagh": range(11568, 11648),
+ "Ethiopic Extended": range(11648, 11744),
+ "Cyrillic Extended-A": range(11744, 11776),
+ "Supplemental Punctuation": range(11776, 11904),
+ "CJK Radicals Supplement": range(11904, 12032),
+ "Kangxi Radicals": range(12032, 12256),
+ "Ideographic Description Characters": range(12272, 12288),
+ "CJK Symbols and Punctuation": range(12288, 12352),
+ "Hiragana": range(12352, 12448),
+ "Katakana": range(12448, 12544),
+ "Bopomofo": range(12544, 12592),
+ "Hangul Compatibility Jamo": range(12592, 12688),
+ "Kanbun": range(12688, 12704),
+ "Bopomofo Extended": range(12704, 12736),
+ "CJK Strokes": range(12736, 12784),
+ "Katakana Phonetic Extensions": range(12784, 12800),
+ "Enclosed CJK Letters and Months": range(12800, 13056),
+ "CJK Compatibility": range(13056, 13312),
+ "CJK Unified Ideographs Extension A": range(13312, 19904),
+ "Yijing Hexagram Symbols": range(19904, 19968),
+ "CJK Unified Ideographs": range(19968, 40960),
+ "Yi Syllables": range(40960, 42128),
+ "Yi Radicals": range(42128, 42192),
+ "Lisu": range(42192, 42240),
+ "Vai": range(42240, 42560),
+ "Cyrillic Extended-B": range(42560, 42656),
+ "Bamum": range(42656, 42752),
+ "Modifier Tone Letters": range(42752, 42784),
+ "Latin Extended-D": range(42784, 43008),
+ "Syloti Nagri": range(43008, 43056),
+ "Common Indic Number Forms": range(43056, 43072),
+ "Phags-pa": range(43072, 43136),
+ "Saurashtra": range(43136, 43232),
+ "Devanagari Extended": range(43232, 43264),
+ "Kayah Li": range(43264, 43312),
+ "Rejang": range(43312, 43360),
+ "Hangul Jamo Extended-A": range(43360, 43392),
+ "Javanese": range(43392, 43488),
+ "Myanmar Extended-B": range(43488, 43520),
+ "Cham": range(43520, 43616),
+ "Myanmar Extended-A": range(43616, 43648),
+ "Tai Viet": range(43648, 43744),
+ "Meetei Mayek Extensions": range(43744, 43776),
+ "Ethiopic Extended-A": range(43776, 43824),
+ "Latin Extended-E": range(43824, 43888),
+ "Cherokee Supplement": range(43888, 43968),
+ "Meetei Mayek": range(43968, 44032),
+ "Hangul Syllables": range(44032, 55216),
+ "Hangul Jamo Extended-B": range(55216, 55296),
+ "High Surrogates": range(55296, 56192),
+ "High Private Use Surrogates": range(56192, 56320),
+ "Low Surrogates": range(56320, 57344),
+ "Private Use Area": range(57344, 63744),
+ "CJK Compatibility Ideographs": range(63744, 64256),
+ "Alphabetic Presentation Forms": range(64256, 64336),
+ "Arabic Presentation Forms-A": range(64336, 65024),
+ "Variation Selectors": range(65024, 65040),
+ "Vertical Forms": range(65040, 65056),
+ "Combining Half Marks": range(65056, 65072),
+ "CJK Compatibility Forms": range(65072, 65104),
+ "Small Form Variants": range(65104, 65136),
+ "Arabic Presentation Forms-B": range(65136, 65280),
+ "Halfwidth and Fullwidth Forms": range(65280, 65520),
+ "Specials": range(65520, 65536),
+ "Linear B Syllabary": range(65536, 65664),
+ "Linear B Ideograms": range(65664, 65792),
+ "Aegean Numbers": range(65792, 65856),
+ "Ancient Greek Numbers": range(65856, 65936),
+ "Ancient Symbols": range(65936, 66000),
+ "Phaistos Disc": range(66000, 66048),
+ "Lycian": range(66176, 66208),
+ "Carian": range(66208, 66272),
+ "Coptic Epact Numbers": range(66272, 66304),
+ "Old Italic": range(66304, 66352),
+ "Gothic": range(66352, 66384),
+ "Old Permic": range(66384, 66432),
+ "Ugaritic": range(66432, 66464),
+ "Old Persian": range(66464, 66528),
+ "Deseret": range(66560, 66640),
+ "Shavian": range(66640, 66688),
+ "Osmanya": range(66688, 66736),
+ "Osage": range(66736, 66816),
+ "Elbasan": range(66816, 66864),
+ "Caucasian Albanian": range(66864, 66928),
+ "Vithkuqi": range(66928, 67008),
+ "Todhri": range(67008, 67072),
+ "Linear A": range(67072, 67456),
+ "Latin Extended-F": range(67456, 67520),
+ "Cypriot Syllabary": range(67584, 67648),
+ "Imperial Aramaic": range(67648, 67680),
+ "Palmyrene": range(67680, 67712),
+ "Nabataean": range(67712, 67760),
+ "Hatran": range(67808, 67840),
+ "Phoenician": range(67840, 67872),
+ "Lydian": range(67872, 67904),
+ "Sidetic": range(67904, 67936),
+ "Meroitic Hieroglyphs": range(67968, 68000),
+ "Meroitic Cursive": range(68000, 68096),
+ "Kharoshthi": range(68096, 68192),
+ "Old South Arabian": range(68192, 68224),
+ "Old North Arabian": range(68224, 68256),
+ "Manichaean": range(68288, 68352),
+ "Avestan": range(68352, 68416),
+ "Inscriptional Parthian": range(68416, 68448),
+ "Inscriptional Pahlavi": range(68448, 68480),
+ "Psalter Pahlavi": range(68480, 68528),
+ "Old Turkic": range(68608, 68688),
+ "Old Hungarian": range(68736, 68864),
+ "Hanifi Rohingya": range(68864, 68928),
+ "Garay": range(68928, 69008),
+ "Rumi Numeral Symbols": range(69216, 69248),
+ "Yezidi": range(69248, 69312),
+ "Arabic Extended-C": range(69312, 69376),
+ "Old Sogdian": range(69376, 69424),
+ "Sogdian": range(69424, 69488),
+ "Old Uyghur": range(69488, 69552),
+ "Chorasmian": range(69552, 69600),
+ "Elymaic": range(69600, 69632),
+ "Brahmi": range(69632, 69760),
+ "Kaithi": range(69760, 69840),
+ "Sora Sompeng": range(69840, 69888),
+ "Chakma": range(69888, 69968),
+ "Mahajani": range(69968, 70016),
+ "Sharada": range(70016, 70112),
+ "Sinhala Archaic Numbers": range(70112, 70144),
+ "Khojki": range(70144, 70224),
+ "Multani": range(70272, 70320),
+ "Khudawadi": range(70320, 70400),
+ "Grantha": range(70400, 70528),
+ "Tulu-Tigalari": range(70528, 70656),
+ "Newa": range(70656, 70784),
+ "Tirhuta": range(70784, 70880),
+ "Siddham": range(71040, 71168),
+ "Modi": range(71168, 71264),
+ "Mongolian Supplement": range(71264, 71296),
+ "Takri": range(71296, 71376),
+ "Myanmar Extended-C": range(71376, 71424),
+ "Ahom": range(71424, 71504),
+ "Dogra": range(71680, 71760),
+ "Warang Citi": range(71840, 71936),
+ "Dives Akuru": range(71936, 72032),
+ "Nandinagari": range(72096, 72192),
+ "Zanabazar Square": range(72192, 72272),
+ "Soyombo": range(72272, 72368),
+ "Unified Canadian Aboriginal Syllabics Extended-A": range(72368, 72384),
+ "Pau Cin Hau": range(72384, 72448),
+ "Devanagari Extended-A": range(72448, 72544),
+ "Sharada Supplement": range(72544, 72576),
+ "Sunuwar": range(72640, 72704),
+ "Bhaiksuki": range(72704, 72816),
+ "Marchen": range(72816, 72896),
+ "Masaram Gondi": range(72960, 73056),
+ "Gunjala Gondi": range(73056, 73136),
+ "Tolong Siki": range(73136, 73200),
+ "Makasar": range(73440, 73472),
+ "Kawi": range(73472, 73568),
+ "Lisu Supplement": range(73648, 73664),
+ "Tamil Supplement": range(73664, 73728),
+ "Cuneiform": range(73728, 74752),
+ "Cuneiform Numbers and Punctuation": range(74752, 74880),
+ "Early Dynastic Cuneiform": range(74880, 75088),
+ "Cypro-Minoan": range(77712, 77824),
+ "Egyptian Hieroglyphs": range(77824, 78896),
+ "Egyptian Hieroglyph Format Controls": range(78896, 78944),
+ "Egyptian Hieroglyphs Extended-A": range(78944, 82944),
+ "Anatolian Hieroglyphs": range(82944, 83584),
+ "Gurung Khema": range(90368, 90432),
+ "Bamum Supplement": range(92160, 92736),
+ "Mro": range(92736, 92784),
+ "Tangsa": range(92784, 92880),
+ "Bassa Vah": range(92880, 92928),
+ "Pahawh Hmong": range(92928, 93072),
+ "Kirat Rai": range(93504, 93568),
+ "Medefaidrin": range(93760, 93856),
+ "Beria Erfe": range(93856, 93920),
+ "Miao": range(93952, 94112),
+ "Ideographic Symbols and Punctuation": range(94176, 94208),
+ "Tangut": range(94208, 100352),
+ "Tangut Components": range(100352, 101120),
+ "Khitan Small Script": range(101120, 101632),
+ "Tangut Supplement": range(101632, 101760),
+ "Tangut Components Supplement": range(101760, 101888),
+ "Kana Extended-B": range(110576, 110592),
+ "Kana Supplement": range(110592, 110848),
+ "Kana Extended-A": range(110848, 110896),
+ "Small Kana Extension": range(110896, 110960),
+ "Nushu": range(110960, 111360),
+ "Duployan": range(113664, 113824),
+ "Shorthand Format Controls": range(113824, 113840),
+ "Symbols for Legacy Computing Supplement": range(117760, 118464),
+ "Miscellaneous Symbols Supplement": range(118464, 118528),
+ "Znamenny Musical Notation": range(118528, 118736),
+ "Byzantine Musical Symbols": range(118784, 119040),
+ "Musical Symbols": range(119040, 119296),
+ "Ancient Greek Musical Notation": range(119296, 119376),
+ "Kaktovik Numerals": range(119488, 119520),
+ "Mayan Numerals": range(119520, 119552),
+ "Tai Xuan Jing Symbols": range(119552, 119648),
+ "Counting Rod Numerals": range(119648, 119680),
+ "Mathematical Alphanumeric Symbols": range(119808, 120832),
+ "Sutton SignWriting": range(120832, 121520),
+ "Latin Extended-G": range(122624, 122880),
+ "Glagolitic Supplement": range(122880, 122928),
+ "Cyrillic Extended-D": range(122928, 123024),
+ "Nyiakeng Puachue Hmong": range(123136, 123216),
+ "Toto": range(123536, 123584),
+ "Wancho": range(123584, 123648),
+ "Nag Mundari": range(124112, 124160),
+ "Ol Onal": range(124368, 124416),
+ "Tai Yo": range(124608, 124672),
+ "Ethiopic Extended-B": range(124896, 124928),
+ "Mende Kikakui": range(124928, 125152),
+ "Adlam": range(125184, 125280),
+ "Indic Siyaq Numbers": range(126064, 126144),
+ "Ottoman Siyaq Numbers": range(126208, 126288),
+ "Arabic Mathematical Alphabetic Symbols": range(126464, 126720),
+ "Mahjong Tiles": range(126976, 127024),
+ "Domino Tiles": range(127024, 127136),
+ "Playing Cards": range(127136, 127232),
+ "Enclosed Alphanumeric Supplement": range(127232, 127488),
+ "Enclosed Ideographic Supplement": range(127488, 127744),
+ "Miscellaneous Symbols and Pictographs": range(127744, 128512),
+ "Emoticons": range(128512, 128592),
+ "Ornamental Dingbats": range(128592, 128640),
+ "Transport and Map Symbols": range(128640, 128768),
+ "Alchemical Symbols": range(128768, 128896),
+ "Geometric Shapes Extended": range(128896, 129024),
+ "Supplemental Arrows-C": range(129024, 129280),
+ "Supplemental Symbols and Pictographs": range(129280, 129536),
+ "Chess Symbols": range(129536, 129648),
+ "Symbols and Pictographs Extended-A": range(129648, 129792),
+ "Symbols for Legacy Computing": range(129792, 130048),
+ "CJK Unified Ideographs Extension B": range(131072, 173792),
+ "CJK Unified Ideographs Extension C": range(173824, 177984),
+ "CJK Unified Ideographs Extension D": range(177984, 178208),
+ "CJK Unified Ideographs Extension E": range(178208, 183984),
+ "CJK Unified Ideographs Extension F": range(183984, 191472),
+ "CJK Unified Ideographs Extension I": range(191472, 192096),
+ "CJK Compatibility Ideographs Supplement": range(194560, 195104),
+ "CJK Unified Ideographs Extension G": range(196608, 201552),
+ "CJK Unified Ideographs Extension H": range(201552, 205744),
+ "CJK Unified Ideographs Extension J": range(205744, 210048),
+ "Tags": range(917504, 917632),
+ "Variation Selectors Supplement": range(917760, 918000),
+ "Supplementary Private Use Area-A": range(983040, 1048576),
+ "Supplementary Private Use Area-B": range(1048576, 1114112),
+}
+
+
+UNICODE_SECONDARY_RANGE_KEYWORD: list[str] = [
+ "Supplement",
+ "Extended",
+ "Extensions",
+ "Modifier",
+ "Marks",
+ "Punctuation",
+ "Symbols",
+ "Forms",
+ "Operators",
+ "Miscellaneous",
+ "Drawing",
+ "Block",
+ "Shapes",
+ "Supplemental",
+ "Tags",
+]
+
+RE_POSSIBLE_ENCODING_INDICATION = re_compile(
+ r"(?:(?:encoding)|(?:charset)|(?:coding))(?:[\:= ]{1,10})(?:[\"\']?)([a-zA-Z0-9\-_]+)(?:[\"\']?)",
+ IGNORECASE,
+)
+
+IANA_NO_ALIASES = [
+ "cp720",
+ "cp737",
+ "cp856",
+ "cp874",
+ "cp875",
+ "cp1006",
+ "koi8_r",
+ "koi8_t",
+ "koi8_u",
+]
+
+IANA_SUPPORTED: list[str] = sorted(
+ filter(
+ lambda x: x.endswith("_codec") is False
+ and x not in {"rot_13", "tactis", "mbcs"},
+ list(set(aliases.values())) + IANA_NO_ALIASES,
+ )
+)
+
+IANA_SUPPORTED_COUNT: int = len(IANA_SUPPORTED)
+
+# pre-computed code page that are similar using the function cp_similarity.
+IANA_SUPPORTED_SIMILAR: dict[str, list[str]] = {
+ "cp037": ["cp1026", "cp1140", "cp273", "cp500"],
+ "cp1026": ["cp037", "cp1140", "cp273", "cp500"],
+ "cp1125": ["cp866"],
+ "cp1140": ["cp037", "cp1026", "cp273", "cp500"],
+ "cp1250": ["iso8859_2"],
+ "cp1251": ["kz1048", "ptcp154"],
+ "cp1252": ["iso8859_15", "iso8859_9", "latin_1"],
+ "cp1253": ["iso8859_7"],
+ "cp1254": ["iso8859_15", "iso8859_9", "latin_1"],
+ "cp1257": ["iso8859_13"],
+ "cp273": ["cp037", "cp1026", "cp1140", "cp500"],
+ "cp437": ["cp850", "cp858", "cp860", "cp861", "cp862", "cp863", "cp865"],
+ "cp500": ["cp037", "cp1026", "cp1140", "cp273"],
+ "cp850": ["cp437", "cp857", "cp858", "cp865"],
+ "cp857": ["cp850", "cp858", "cp865"],
+ "cp858": ["cp437", "cp850", "cp857", "cp865"],
+ "cp860": ["cp437", "cp861", "cp862", "cp863", "cp865"],
+ "cp861": ["cp437", "cp860", "cp862", "cp863", "cp865"],
+ "cp862": ["cp437", "cp860", "cp861", "cp863", "cp865"],
+ "cp863": ["cp437", "cp860", "cp861", "cp862", "cp865"],
+ "cp865": ["cp437", "cp850", "cp857", "cp858", "cp860", "cp861", "cp862", "cp863"],
+ "cp866": ["cp1125"],
+ "iso8859_10": ["iso8859_14", "iso8859_15", "iso8859_4", "iso8859_9", "latin_1"],
+ "iso8859_11": ["tis_620"],
+ "iso8859_13": ["cp1257"],
+ "iso8859_14": [
+ "iso8859_10",
+ "iso8859_15",
+ "iso8859_16",
+ "iso8859_3",
+ "iso8859_9",
+ "latin_1",
+ ],
+ "iso8859_15": [
+ "cp1252",
+ "cp1254",
+ "iso8859_10",
+ "iso8859_14",
+ "iso8859_16",
+ "iso8859_3",
+ "iso8859_9",
+ "latin_1",
+ ],
+ "iso8859_16": [
+ "iso8859_14",
+ "iso8859_15",
+ "iso8859_2",
+ "iso8859_3",
+ "iso8859_9",
+ "latin_1",
+ ],
+ "iso8859_2": ["cp1250", "iso8859_16", "iso8859_4"],
+ "iso8859_3": ["iso8859_14", "iso8859_15", "iso8859_16", "iso8859_9", "latin_1"],
+ "iso8859_4": ["iso8859_10", "iso8859_2", "iso8859_9", "latin_1"],
+ "iso8859_7": ["cp1253"],
+ "iso8859_9": [
+ "cp1252",
+ "cp1254",
+ "cp1258",
+ "iso8859_10",
+ "iso8859_14",
+ "iso8859_15",
+ "iso8859_16",
+ "iso8859_3",
+ "iso8859_4",
+ "latin_1",
+ ],
+ "kz1048": ["cp1251", "ptcp154"],
+ "latin_1": [
+ "cp1252",
+ "cp1254",
+ "cp1258",
+ "iso8859_10",
+ "iso8859_14",
+ "iso8859_15",
+ "iso8859_16",
+ "iso8859_3",
+ "iso8859_4",
+ "iso8859_9",
+ ],
+ "mac_iceland": ["mac_roman", "mac_turkish"],
+ "mac_roman": ["mac_iceland", "mac_turkish"],
+ "mac_turkish": ["mac_iceland", "mac_roman"],
+ "ptcp154": ["cp1251", "kz1048"],
+ "tis_620": ["iso8859_11"],
+}
+
+
+CHARDET_CORRESPONDENCE: dict[str, str] = {
+ "iso2022_kr": "ISO-2022-KR",
+ "iso2022_jp": "ISO-2022-JP",
+ "euc_kr": "EUC-KR",
+ "tis_620": "TIS-620",
+ "utf_32": "UTF-32",
+ "euc_jp": "EUC-JP",
+ "koi8_r": "KOI8-R",
+ "iso8859_1": "ISO-8859-1",
+ "iso8859_2": "ISO-8859-2",
+ "iso8859_5": "ISO-8859-5",
+ "iso8859_6": "ISO-8859-6",
+ "iso8859_7": "ISO-8859-7",
+ "iso8859_8": "ISO-8859-8",
+ "utf_16": "UTF-16",
+ "cp855": "IBM855",
+ "mac_cyrillic": "MacCyrillic",
+ "gb2312": "GB2312",
+ "gb18030": "GB18030",
+ "cp932": "CP932",
+ "cp866": "IBM866",
+ "utf_8": "utf-8",
+ "utf_8_sig": "UTF-8-SIG",
+ "shift_jis": "SHIFT_JIS",
+ "big5": "Big5",
+ "cp1250": "windows-1250",
+ "cp1251": "windows-1251",
+ "cp1252": "Windows-1252",
+ "cp1253": "windows-1253",
+ "cp1255": "windows-1255",
+ "cp1256": "windows-1256",
+ "cp1254": "Windows-1254",
+ "cp949": "CP949",
+}
+
+
+COMMON_SAFE_ASCII_CHARACTERS: frozenset[str] = frozenset(
+ {
+ "<",
+ ">",
+ "=",
+ ":",
+ "/",
+ "&",
+ ";",
+ "{",
+ "}",
+ "[",
+ "]",
+ ",",
+ "|",
+ '"',
+ "-",
+ "(",
+ ")",
+ }
+)
+
+# Sample character sets — replace with full lists if needed
+COMMON_CHINESE_CHARACTERS = "的一是在不了有和人这中大为上个国我以要他时来用们生到作地于出就分对成会可主发年动同工也能下过子说产种面而方后多定行学法所民得经十三之进着等部度家电力里如水化高自二理起小物现实加量都两体制机当使点从业本去把性好应开它合还因由其些然前外天政四日那社义事平形相全表间样与关各重新线内数正心反你明看原又么利比或但质气第向道命此变条只没结解问意建月公无系军很情者最立代想已通并提直题党程展五果料象员革位入常文总次品式活设及管特件长求老头基资边流路级少图山统接知较将组见计别她手角期根论运农指几九区强放决西被干做必战先回则任取据处队南给色光门即保治北造百规热领七海口东导器压志世金增争济阶油思术极交受联什认六共权收证改清己美再采转更单风切打白教速花带安场身车例真务具万每目至达走积示议声报斗完类八离华名确才科张信马节话米整空元况今集温传土许步群广石记需段研界拉林律叫且究观越织装影算低持音众书布复容儿须际商非验连断深难近矿千周委素技备半办青省列习响约支般史感劳便团往酸历市克何除消构府太准精值号率族维划选标写存候毛亲快效斯院查江型眼王按格养易置派层片始却专状育厂京识适属圆包火住调满县局照参红细引听该铁价严龙飞"
+
+COMMON_JAPANESE_CHARACTERS = "日一国年大十二本中長出三時行見月分後前生五間上東四今金九入学高円子外八六下来気小七山話女北午百書先名川千水半男西電校語土木聞食車何南万毎白天母火右読友左休父雨"
+
+COMMON_KOREAN_CHARACTERS = "一二三四五六七八九十百千萬上下左右中人女子大小山川日月火水木金土父母天地國名年時文校學生"
+
+# Combine all into a frozenset
+COMMON_CJK_CHARACTERS = frozenset(
+ "".join(
+ [
+ COMMON_CHINESE_CHARACTERS,
+ COMMON_JAPANESE_CHARACTERS,
+ COMMON_KOREAN_CHARACTERS,
+ ]
+ )
+)
+
+KO_NAMES: frozenset[str] = frozenset({"johab", "cp949", "euc_kr"})
+ZH_NAMES: frozenset[str] = frozenset({"big5", "cp950", "big5hkscs", "hz"})
+
+# Logging LEVEL below DEBUG
+TRACE: int = 5
+
+
+# Language label that contain the em dash "—"
+# character are to be considered alternative seq to origin
+FREQUENCIES: dict[str, list[str]] = {
+ "English": [
+ "e",
+ "a",
+ "t",
+ "i",
+ "o",
+ "n",
+ "s",
+ "r",
+ "h",
+ "l",
+ "d",
+ "c",
+ "u",
+ "m",
+ "f",
+ "p",
+ "g",
+ "w",
+ "y",
+ "b",
+ "v",
+ "k",
+ "x",
+ "j",
+ "z",
+ "q",
+ ],
+ "English—": [
+ "e",
+ "a",
+ "t",
+ "i",
+ "o",
+ "n",
+ "s",
+ "r",
+ "h",
+ "l",
+ "d",
+ "c",
+ "m",
+ "u",
+ "f",
+ "p",
+ "g",
+ "w",
+ "b",
+ "y",
+ "v",
+ "k",
+ "j",
+ "x",
+ "z",
+ "q",
+ ],
+ "German": [
+ "e",
+ "n",
+ "i",
+ "r",
+ "s",
+ "t",
+ "a",
+ "d",
+ "h",
+ "u",
+ "l",
+ "g",
+ "o",
+ "c",
+ "m",
+ "b",
+ "f",
+ "k",
+ "w",
+ "z",
+ "p",
+ "v",
+ "ü",
+ "ä",
+ "ö",
+ "j",
+ ],
+ "French": [
+ "e",
+ "a",
+ "s",
+ "n",
+ "i",
+ "t",
+ "r",
+ "l",
+ "u",
+ "o",
+ "d",
+ "c",
+ "p",
+ "m",
+ "é",
+ "v",
+ "g",
+ "f",
+ "b",
+ "h",
+ "q",
+ "à",
+ "x",
+ "è",
+ "y",
+ "j",
+ ],
+ "Dutch": [
+ "e",
+ "n",
+ "a",
+ "i",
+ "r",
+ "t",
+ "o",
+ "d",
+ "s",
+ "l",
+ "g",
+ "h",
+ "v",
+ "m",
+ "u",
+ "k",
+ "c",
+ "p",
+ "b",
+ "w",
+ "j",
+ "z",
+ "f",
+ "y",
+ "x",
+ "ë",
+ ],
+ "Italian": [
+ "e",
+ "i",
+ "a",
+ "o",
+ "n",
+ "l",
+ "t",
+ "r",
+ "s",
+ "c",
+ "d",
+ "u",
+ "p",
+ "m",
+ "g",
+ "v",
+ "f",
+ "b",
+ "z",
+ "h",
+ "q",
+ "è",
+ "à",
+ "k",
+ "y",
+ "ò",
+ ],
+ "Polish": [
+ "a",
+ "i",
+ "o",
+ "e",
+ "n",
+ "r",
+ "z",
+ "w",
+ "s",
+ "c",
+ "t",
+ "k",
+ "y",
+ "d",
+ "p",
+ "m",
+ "u",
+ "l",
+ "j",
+ "ł",
+ "g",
+ "b",
+ "h",
+ "ą",
+ "ę",
+ "ó",
+ ],
+ "Spanish": [
+ "e",
+ "a",
+ "o",
+ "n",
+ "s",
+ "r",
+ "i",
+ "l",
+ "d",
+ "t",
+ "c",
+ "u",
+ "m",
+ "p",
+ "b",
+ "g",
+ "v",
+ "f",
+ "y",
+ "ó",
+ "h",
+ "q",
+ "í",
+ "j",
+ "z",
+ "á",
+ ],
+ "Russian": [
+ "о",
+ "е",
+ "а",
+ "и",
+ "н",
+ "т",
+ "с",
+ "р",
+ "в",
+ "л",
+ "к",
+ "м",
+ "д",
+ "п",
+ "у",
+ "г",
+ "я",
+ "ы",
+ "з",
+ "б",
+ "й",
+ "ь",
+ "ч",
+ "х",
+ "ж",
+ "ц",
+ ],
+ # Jap-Kanji
+ "Japanese": [
+ "日",
+ "一",
+ "人",
+ "年",
+ "大",
+ "十",
+ "二",
+ "本",
+ "中",
+ "長",
+ "出",
+ "三",
+ "時",
+ "行",
+ "見",
+ "月",
+ "分",
+ "後",
+ "前",
+ "生",
+ "五",
+ "間",
+ "上",
+ "東",
+ "四",
+ "今",
+ "金",
+ "九",
+ "入",
+ "学",
+ "高",
+ "円",
+ "子",
+ "外",
+ "八",
+ "六",
+ "下",
+ "来",
+ "気",
+ "小",
+ "七",
+ "山",
+ "話",
+ "女",
+ "北",
+ "午",
+ "百",
+ "書",
+ "先",
+ "名",
+ "川",
+ "千",
+ "水",
+ "半",
+ "男",
+ "西",
+ "電",
+ "校",
+ "語",
+ "土",
+ "木",
+ "聞",
+ "食",
+ "車",
+ "何",
+ "南",
+ "万",
+ "毎",
+ "白",
+ "天",
+ "母",
+ "火",
+ "右",
+ "読",
+ "友",
+ "左",
+ "休",
+ "父",
+ "雨",
+ ],
+ # Jap-Katakana
+ "Japanese—": [
+ "ー",
+ "ン",
+ "ス",
+ "・",
+ "ル",
+ "ト",
+ "リ",
+ "イ",
+ "ア",
+ "ラ",
+ "ッ",
+ "ク",
+ "ド",
+ "シ",
+ "レ",
+ "ジ",
+ "タ",
+ "フ",
+ "ロ",
+ "カ",
+ "テ",
+ "マ",
+ "ィ",
+ "グ",
+ "バ",
+ "ム",
+ "プ",
+ "オ",
+ "コ",
+ "デ",
+ "ニ",
+ "ウ",
+ "メ",
+ "サ",
+ "ビ",
+ "ナ",
+ "ブ",
+ "ャ",
+ "エ",
+ "ュ",
+ "チ",
+ "キ",
+ "ズ",
+ "ダ",
+ "パ",
+ "ミ",
+ "ェ",
+ "ョ",
+ "ハ",
+ "セ",
+ "ベ",
+ "ガ",
+ "モ",
+ "ツ",
+ "ネ",
+ "ボ",
+ "ソ",
+ "ノ",
+ "ァ",
+ "ヴ",
+ "ワ",
+ "ポ",
+ "ペ",
+ "ピ",
+ "ケ",
+ "ゴ",
+ "ギ",
+ "ザ",
+ "ホ",
+ "ゲ",
+ "ォ",
+ "ヤ",
+ "ヒ",
+ "ユ",
+ "ヨ",
+ "ヘ",
+ "ゼ",
+ "ヌ",
+ "ゥ",
+ "ゾ",
+ "ヶ",
+ "ヂ",
+ "ヲ",
+ "ヅ",
+ "ヵ",
+ "ヱ",
+ "ヰ",
+ "ヮ",
+ "ヽ",
+ "゠",
+ "ヾ",
+ "ヷ",
+ "ヿ",
+ "ヸ",
+ "ヹ",
+ "ヺ",
+ ],
+ # Jap-Hiragana
+ "Japanese——": [
+ "の",
+ "に",
+ "る",
+ "た",
+ "と",
+ "は",
+ "し",
+ "い",
+ "を",
+ "で",
+ "て",
+ "が",
+ "な",
+ "れ",
+ "か",
+ "ら",
+ "さ",
+ "っ",
+ "り",
+ "す",
+ "あ",
+ "も",
+ "こ",
+ "ま",
+ "う",
+ "く",
+ "よ",
+ "き",
+ "ん",
+ "め",
+ "お",
+ "け",
+ "そ",
+ "つ",
+ "だ",
+ "や",
+ "え",
+ "ど",
+ "わ",
+ "ち",
+ "み",
+ "せ",
+ "じ",
+ "ば",
+ "へ",
+ "び",
+ "ず",
+ "ろ",
+ "ほ",
+ "げ",
+ "む",
+ "べ",
+ "ひ",
+ "ょ",
+ "ゆ",
+ "ぶ",
+ "ご",
+ "ゃ",
+ "ね",
+ "ふ",
+ "ぐ",
+ "ぎ",
+ "ぼ",
+ "ゅ",
+ "づ",
+ "ざ",
+ "ぞ",
+ "ぬ",
+ "ぜ",
+ "ぱ",
+ "ぽ",
+ "ぷ",
+ "ぴ",
+ "ぃ",
+ "ぁ",
+ "ぇ",
+ "ぺ",
+ "ゞ",
+ "ぢ",
+ "ぉ",
+ "ぅ",
+ "ゐ",
+ "ゝ",
+ "ゑ",
+ "゛",
+ "゜",
+ "ゎ",
+ "ゔ",
+ "゚",
+ "ゟ",
+ "゙",
+ "ゕ",
+ "ゖ",
+ ],
+ "Portuguese": [
+ "a",
+ "e",
+ "o",
+ "s",
+ "i",
+ "r",
+ "d",
+ "n",
+ "t",
+ "m",
+ "u",
+ "c",
+ "l",
+ "p",
+ "g",
+ "v",
+ "b",
+ "f",
+ "h",
+ "ã",
+ "q",
+ "é",
+ "ç",
+ "á",
+ "z",
+ "í",
+ ],
+ "Swedish": [
+ "e",
+ "a",
+ "n",
+ "r",
+ "t",
+ "s",
+ "i",
+ "l",
+ "d",
+ "o",
+ "m",
+ "k",
+ "g",
+ "v",
+ "h",
+ "f",
+ "u",
+ "p",
+ "ä",
+ "c",
+ "b",
+ "ö",
+ "å",
+ "y",
+ "j",
+ "x",
+ ],
+ "Chinese": [
+ "的",
+ "一",
+ "是",
+ "不",
+ "了",
+ "在",
+ "人",
+ "有",
+ "我",
+ "他",
+ "这",
+ "个",
+ "们",
+ "中",
+ "来",
+ "上",
+ "大",
+ "为",
+ "和",
+ "国",
+ "地",
+ "到",
+ "以",
+ "说",
+ "时",
+ "要",
+ "就",
+ "出",
+ "会",
+ "可",
+ "也",
+ "你",
+ "对",
+ "生",
+ "能",
+ "而",
+ "子",
+ "那",
+ "得",
+ "于",
+ "着",
+ "下",
+ "自",
+ "之",
+ "年",
+ "过",
+ "发",
+ "后",
+ "作",
+ "里",
+ "用",
+ "道",
+ "行",
+ "所",
+ "然",
+ "家",
+ "种",
+ "事",
+ "成",
+ "方",
+ "多",
+ "经",
+ "么",
+ "去",
+ "法",
+ "学",
+ "如",
+ "都",
+ "同",
+ "现",
+ "当",
+ "没",
+ "动",
+ "面",
+ "起",
+ "看",
+ "定",
+ "天",
+ "分",
+ "还",
+ "进",
+ "好",
+ "小",
+ "部",
+ "其",
+ "些",
+ "主",
+ "样",
+ "理",
+ "心",
+ "她",
+ "本",
+ "前",
+ "开",
+ "但",
+ "因",
+ "只",
+ "从",
+ "想",
+ "实",
+ ],
+ "Ukrainian": [
+ "о",
+ "а",
+ "н",
+ "і",
+ "и",
+ "р",
+ "в",
+ "т",
+ "е",
+ "с",
+ "к",
+ "л",
+ "у",
+ "д",
+ "м",
+ "п",
+ "з",
+ "я",
+ "ь",
+ "б",
+ "г",
+ "й",
+ "ч",
+ "х",
+ "ц",
+ "ї",
+ ],
+ "Norwegian": [
+ "e",
+ "r",
+ "n",
+ "t",
+ "a",
+ "s",
+ "i",
+ "o",
+ "l",
+ "d",
+ "g",
+ "k",
+ "m",
+ "v",
+ "f",
+ "p",
+ "u",
+ "b",
+ "h",
+ "å",
+ "y",
+ "j",
+ "ø",
+ "c",
+ "æ",
+ "w",
+ ],
+ "Finnish": [
+ "a",
+ "i",
+ "n",
+ "t",
+ "e",
+ "s",
+ "l",
+ "o",
+ "u",
+ "k",
+ "ä",
+ "m",
+ "r",
+ "v",
+ "j",
+ "h",
+ "p",
+ "y",
+ "d",
+ "ö",
+ "g",
+ "c",
+ "b",
+ "f",
+ "w",
+ "z",
+ ],
+ "Vietnamese": [
+ "n",
+ "h",
+ "t",
+ "i",
+ "c",
+ "g",
+ "a",
+ "o",
+ "u",
+ "m",
+ "l",
+ "r",
+ "à",
+ "đ",
+ "s",
+ "e",
+ "v",
+ "p",
+ "b",
+ "y",
+ "ư",
+ "d",
+ "á",
+ "k",
+ "ộ",
+ "ế",
+ ],
+ "Czech": [
+ "o",
+ "e",
+ "a",
+ "n",
+ "t",
+ "s",
+ "i",
+ "l",
+ "v",
+ "r",
+ "k",
+ "d",
+ "u",
+ "m",
+ "p",
+ "í",
+ "c",
+ "h",
+ "z",
+ "á",
+ "y",
+ "j",
+ "b",
+ "ě",
+ "é",
+ "ř",
+ ],
+ "Hungarian": [
+ "e",
+ "a",
+ "t",
+ "l",
+ "s",
+ "n",
+ "k",
+ "r",
+ "i",
+ "o",
+ "z",
+ "á",
+ "é",
+ "g",
+ "m",
+ "b",
+ "y",
+ "v",
+ "d",
+ "h",
+ "u",
+ "p",
+ "j",
+ "ö",
+ "f",
+ "c",
+ ],
+ "Korean": [
+ "이",
+ "다",
+ "에",
+ "의",
+ "는",
+ "로",
+ "하",
+ "을",
+ "가",
+ "고",
+ "지",
+ "서",
+ "한",
+ "은",
+ "기",
+ "으",
+ "년",
+ "대",
+ "사",
+ "시",
+ "를",
+ "리",
+ "도",
+ "인",
+ "스",
+ "일",
+ ],
+ "Indonesian": [
+ "a",
+ "n",
+ "e",
+ "i",
+ "r",
+ "t",
+ "u",
+ "s",
+ "d",
+ "k",
+ "m",
+ "l",
+ "g",
+ "p",
+ "b",
+ "o",
+ "h",
+ "y",
+ "j",
+ "c",
+ "w",
+ "f",
+ "v",
+ "z",
+ "x",
+ "q",
+ ],
+ "Turkish": [
+ "a",
+ "e",
+ "i",
+ "n",
+ "r",
+ "l",
+ "ı",
+ "k",
+ "d",
+ "t",
+ "s",
+ "m",
+ "y",
+ "u",
+ "o",
+ "b",
+ "ü",
+ "ş",
+ "v",
+ "g",
+ "z",
+ "h",
+ "c",
+ "p",
+ "ç",
+ "ğ",
+ ],
+ "Romanian": [
+ "e",
+ "i",
+ "a",
+ "r",
+ "n",
+ "t",
+ "u",
+ "l",
+ "o",
+ "c",
+ "s",
+ "d",
+ "p",
+ "m",
+ "ă",
+ "f",
+ "v",
+ "î",
+ "g",
+ "b",
+ "ș",
+ "ț",
+ "z",
+ "h",
+ "â",
+ "j",
+ ],
+ "Farsi": [
+ "ا",
+ "ی",
+ "ر",
+ "د",
+ "ن",
+ "ه",
+ "و",
+ "م",
+ "ت",
+ "ب",
+ "س",
+ "ل",
+ "ک",
+ "ش",
+ "ز",
+ "ف",
+ "گ",
+ "ع",
+ "خ",
+ "ق",
+ "ج",
+ "آ",
+ "پ",
+ "ح",
+ "ط",
+ "ص",
+ ],
+ "Arabic": [
+ "ا",
+ "ل",
+ "ي",
+ "م",
+ "و",
+ "ن",
+ "ر",
+ "ت",
+ "ب",
+ "ة",
+ "ع",
+ "د",
+ "س",
+ "ف",
+ "ه",
+ "ك",
+ "ق",
+ "أ",
+ "ح",
+ "ج",
+ "ش",
+ "ط",
+ "ص",
+ "ى",
+ "خ",
+ "إ",
+ ],
+ "Danish": [
+ "e",
+ "r",
+ "n",
+ "t",
+ "a",
+ "i",
+ "s",
+ "d",
+ "l",
+ "o",
+ "g",
+ "m",
+ "k",
+ "f",
+ "v",
+ "u",
+ "b",
+ "h",
+ "p",
+ "å",
+ "y",
+ "ø",
+ "æ",
+ "c",
+ "j",
+ "w",
+ ],
+ "Serbian": [
+ "а",
+ "и",
+ "о",
+ "е",
+ "н",
+ "р",
+ "с",
+ "у",
+ "т",
+ "к",
+ "ј",
+ "в",
+ "д",
+ "м",
+ "п",
+ "л",
+ "г",
+ "з",
+ "б",
+ "a",
+ "i",
+ "e",
+ "o",
+ "n",
+ "ц",
+ "ш",
+ ],
+ "Lithuanian": [
+ "i",
+ "a",
+ "s",
+ "o",
+ "r",
+ "e",
+ "t",
+ "n",
+ "u",
+ "k",
+ "m",
+ "l",
+ "p",
+ "v",
+ "d",
+ "j",
+ "g",
+ "ė",
+ "b",
+ "y",
+ "ų",
+ "š",
+ "ž",
+ "c",
+ "ą",
+ "į",
+ ],
+ "Slovene": [
+ "e",
+ "a",
+ "i",
+ "o",
+ "n",
+ "r",
+ "s",
+ "l",
+ "t",
+ "j",
+ "v",
+ "k",
+ "d",
+ "p",
+ "m",
+ "u",
+ "z",
+ "b",
+ "g",
+ "h",
+ "č",
+ "c",
+ "š",
+ "ž",
+ "f",
+ "y",
+ ],
+ "Slovak": [
+ "o",
+ "a",
+ "e",
+ "n",
+ "i",
+ "r",
+ "v",
+ "t",
+ "s",
+ "l",
+ "k",
+ "d",
+ "m",
+ "p",
+ "u",
+ "c",
+ "h",
+ "j",
+ "b",
+ "z",
+ "á",
+ "y",
+ "ý",
+ "í",
+ "č",
+ "é",
+ ],
+ "Hebrew": [
+ "י",
+ "ו",
+ "ה",
+ "ל",
+ "ר",
+ "ב",
+ "ת",
+ "מ",
+ "א",
+ "ש",
+ "נ",
+ "ע",
+ "ם",
+ "ד",
+ "ק",
+ "ח",
+ "פ",
+ "ס",
+ "כ",
+ "ג",
+ "ט",
+ "צ",
+ "ן",
+ "ז",
+ "ך",
+ ],
+ "Bulgarian": [
+ "а",
+ "и",
+ "о",
+ "е",
+ "н",
+ "т",
+ "р",
+ "с",
+ "в",
+ "л",
+ "к",
+ "д",
+ "п",
+ "м",
+ "з",
+ "г",
+ "я",
+ "ъ",
+ "у",
+ "б",
+ "ч",
+ "ц",
+ "й",
+ "ж",
+ "щ",
+ "х",
+ ],
+ "Croatian": [
+ "a",
+ "i",
+ "o",
+ "e",
+ "n",
+ "r",
+ "j",
+ "s",
+ "t",
+ "u",
+ "k",
+ "l",
+ "v",
+ "d",
+ "m",
+ "p",
+ "g",
+ "z",
+ "b",
+ "c",
+ "č",
+ "h",
+ "š",
+ "ž",
+ "ć",
+ "f",
+ ],
+ "Hindi": [
+ "क",
+ "र",
+ "स",
+ "न",
+ "त",
+ "म",
+ "ह",
+ "प",
+ "य",
+ "ल",
+ "व",
+ "ज",
+ "द",
+ "ग",
+ "ब",
+ "श",
+ "ट",
+ "अ",
+ "ए",
+ "थ",
+ "भ",
+ "ड",
+ "च",
+ "ध",
+ "ष",
+ "इ",
+ ],
+ "Estonian": [
+ "a",
+ "i",
+ "e",
+ "s",
+ "t",
+ "l",
+ "u",
+ "n",
+ "o",
+ "k",
+ "r",
+ "d",
+ "m",
+ "v",
+ "g",
+ "p",
+ "j",
+ "h",
+ "ä",
+ "b",
+ "õ",
+ "ü",
+ "f",
+ "c",
+ "ö",
+ "y",
+ ],
+ "Thai": [
+ "า",
+ "น",
+ "ร",
+ "อ",
+ "ก",
+ "เ",
+ "ง",
+ "ม",
+ "ย",
+ "ล",
+ "ว",
+ "ด",
+ "ท",
+ "ส",
+ "ต",
+ "ะ",
+ "ป",
+ "บ",
+ "ค",
+ "ห",
+ "แ",
+ "จ",
+ "พ",
+ "ช",
+ "ข",
+ "ใ",
+ ],
+ "Greek": [
+ "α",
+ "τ",
+ "ο",
+ "ι",
+ "ε",
+ "ν",
+ "ρ",
+ "σ",
+ "κ",
+ "η",
+ "π",
+ "ς",
+ "υ",
+ "μ",
+ "λ",
+ "ί",
+ "ό",
+ "ά",
+ "γ",
+ "έ",
+ "δ",
+ "ή",
+ "ω",
+ "χ",
+ "θ",
+ "ύ",
+ ],
+ "Tamil": [
+ "க",
+ "த",
+ "ப",
+ "ட",
+ "ர",
+ "ம",
+ "ல",
+ "ன",
+ "வ",
+ "ற",
+ "ய",
+ "ள",
+ "ச",
+ "ந",
+ "இ",
+ "ண",
+ "அ",
+ "ஆ",
+ "ழ",
+ "ங",
+ "எ",
+ "உ",
+ "ஒ",
+ "ஸ",
+ ],
+ "Kazakh": [
+ "а",
+ "ы",
+ "е",
+ "н",
+ "т",
+ "р",
+ "л",
+ "і",
+ "д",
+ "с",
+ "м",
+ "қ",
+ "к",
+ "о",
+ "б",
+ "и",
+ "у",
+ "ғ",
+ "ж",
+ "ң",
+ "з",
+ "ш",
+ "й",
+ "п",
+ "г",
+ "ө",
+ ],
+}
+
+LANGUAGE_SUPPORTED_COUNT: int = len(FREQUENCIES)
+
+# Bit flags for unified character classification.
+# A single unicodedata.name() call sets all relevant flags at once.
+_LATIN: int = 1
+_ACCENTUATED: int = 1 << 1
+_CJK: int = 1 << 2
+_HANGUL: int = 1 << 3
+_KATAKANA: int = 1 << 4
+_HIRAGANA: int = 1 << 5
+_THAI: int = 1 << 6
+_ARABIC: int = 1 << 7
+_ARABIC_ISOLATED_FORM: int = 1 << 8
+
+_ACCENT_KEYWORDS: tuple[str, ...] = (
+ "WITH GRAVE",
+ "WITH ACUTE",
+ "WITH CEDILLA",
+ "WITH DIAERESIS",
+ "WITH CIRCUMFLEX",
+ "WITH TILDE",
+ "WITH MACRON",
+ "WITH RING ABOVE",
+)
+
+# Pre-built lookup structures for FREQUENCIES (computed once at import time).
+# character -> rank mapping per language (replaces list .index() calls).
+_FREQUENCIES_RANK: dict[str, dict[str, int]] = {
+ lang: {char: rank for rank, char in enumerate(chars)}
+ for lang, chars in FREQUENCIES.items()
+}
+
+# frozenset per language (avoids rebuilding set() per call).
+_FREQUENCIES_SET: dict[str, frozenset[str]] = {
+ lang: frozenset(chars) for lang, chars in FREQUENCIES.items()
+}
diff --git a/python/user_packages/Python313/site-packages/charset_normalizer/legacy.py b/python/user_packages/Python313/site-packages/charset_normalizer/legacy.py
new file mode 100644
index 0000000000000000000000000000000000000000..c7c0b0d8a37c99b70f804db5620079ad20512923
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/charset_normalizer/legacy.py
@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+from warnings import warn
+
+from .api import from_bytes
+from .constant import CHARDET_CORRESPONDENCE, TOO_SMALL_SEQUENCE
+
+if TYPE_CHECKING:
+ from typing import TypedDict
+
+ class ResultDict(TypedDict):
+ encoding: str | None
+ language: str
+ confidence: float | None
+
+
+def detect(
+ byte_str: bytes, should_rename_legacy: bool = False, **kwargs: Any
+) -> ResultDict:
+ """
+ chardet legacy method
+ Detect the encoding of the given byte string. It should be mostly backward-compatible.
+ Encoding name will match Chardet own writing whenever possible. (Not on encoding name unsupported by it)
+ This function is deprecated and should be used to migrate your project easily, consult the documentation for
+ further information. Not planned for removal.
+
+ :param byte_str: The byte sequence to examine.
+ :param should_rename_legacy: Should we rename legacy encodings
+ to their more modern equivalents?
+ """
+ if len(kwargs):
+ warn(
+ f"charset-normalizer disregard arguments '{','.join(list(kwargs.keys()))}' in legacy function detect()"
+ )
+
+ if not isinstance(byte_str, (bytearray, bytes)):
+ raise TypeError( # pragma: nocover
+ f"Expected object of type bytes or bytearray, got: {type(byte_str)}"
+ )
+
+ if isinstance(byte_str, bytearray):
+ byte_str = bytes(byte_str)
+
+ r = from_bytes(byte_str).best()
+
+ encoding = r.encoding if r is not None else None
+ language = r.language if r is not None and r.language != "Unknown" else ""
+ confidence = 1.0 - r.chaos if r is not None else None
+
+ # automatically lower confidence
+ # on small bytes samples.
+ # https://github.com/jawah/charset_normalizer/issues/391
+ if (
+ confidence is not None
+ and confidence >= 0.9
+ and encoding
+ not in {
+ "utf_8",
+ "ascii",
+ }
+ and r.bom is False # type: ignore[union-attr]
+ and len(byte_str) < TOO_SMALL_SEQUENCE
+ ):
+ confidence -= 0.2
+
+ # Note: CharsetNormalizer does not return 'UTF-8-SIG' as the sig get stripped in the detection/normalization process
+ # but chardet does return 'utf-8-sig' and it is a valid codec name.
+ if r is not None and encoding == "utf_8" and r.bom:
+ encoding += "_sig"
+
+ if should_rename_legacy is False and encoding in CHARDET_CORRESPONDENCE:
+ encoding = CHARDET_CORRESPONDENCE[encoding]
+
+ return {
+ "encoding": encoding,
+ "language": language,
+ "confidence": confidence,
+ }
diff --git a/python/user_packages/Python313/site-packages/charset_normalizer/md.cp313-win_amd64.pyd b/python/user_packages/Python313/site-packages/charset_normalizer/md.cp313-win_amd64.pyd
new file mode 100644
index 0000000000000000000000000000000000000000..a766761830baed245aec1f59dd07ecd767034447
Binary files /dev/null and b/python/user_packages/Python313/site-packages/charset_normalizer/md.cp313-win_amd64.pyd differ
diff --git a/python/user_packages/Python313/site-packages/charset_normalizer/md.py b/python/user_packages/Python313/site-packages/charset_normalizer/md.py
new file mode 100644
index 0000000000000000000000000000000000000000..e7f0c132c955c603c668d5ff36ea0b166139bfe6
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/charset_normalizer/md.py
@@ -0,0 +1,936 @@
+from __future__ import annotations
+
+import sys
+from functools import lru_cache
+from logging import getLogger
+
+if sys.version_info >= (3, 8):
+ from typing import final
+else:
+ try:
+ from typing_extensions import final
+ except ImportError:
+
+ def final(cls): # type: ignore[misc,no-untyped-def]
+ return cls
+
+
+from .constant import (
+ COMMON_CJK_CHARACTERS,
+ COMMON_SAFE_ASCII_CHARACTERS,
+ TRACE,
+ UNICODE_SECONDARY_RANGE_KEYWORD,
+ _ACCENTUATED,
+ _ARABIC,
+ _ARABIC_ISOLATED_FORM,
+ _CJK,
+ _HANGUL,
+ _HIRAGANA,
+ _KATAKANA,
+ _LATIN,
+ _THAI,
+)
+from .utils import (
+ _character_flags,
+ is_emoticon,
+ is_punctuation,
+ is_separator,
+ is_symbol,
+ remove_accent,
+ unicode_range,
+)
+
+# Combined bitmask for CJK/Hangul/Katakana/Hiragana/Thai glyph detection.
+_GLYPH_MASK: int = _CJK | _HANGUL | _KATAKANA | _HIRAGANA | _THAI
+
+
+@final
+class CharInfo:
+ """Pre-computed character properties shared across all detectors.
+
+ Instantiated once and reused via :meth:`update` on every character
+ in the hot loop so that redundant calls to str methods
+ (``isalpha``, ``isupper``, …) and cached utility functions
+ (``_character_flags``, ``is_punctuation``, …) are avoided when
+ several plugins need the same information.
+ """
+
+ __slots__ = (
+ "character",
+ "printable",
+ "alpha",
+ "upper",
+ "lower",
+ "space",
+ "digit",
+ "is_ascii",
+ "case_variable",
+ "flags",
+ "accentuated",
+ "latin",
+ "is_cjk",
+ "is_arabic",
+ "is_glyph",
+ "punct",
+ "sym",
+ )
+
+ def __init__(self) -> None:
+ self.character: str = ""
+ self.printable: bool = False
+ self.alpha: bool = False
+ self.upper: bool = False
+ self.lower: bool = False
+ self.space: bool = False
+ self.digit: bool = False
+ self.is_ascii: bool = False
+ self.case_variable: bool = False
+ self.flags: int = 0
+ self.accentuated: bool = False
+ self.latin: bool = False
+ self.is_cjk: bool = False
+ self.is_arabic: bool = False
+ self.is_glyph: bool = False
+ self.punct: bool = False
+ self.sym: bool = False
+
+ def update(self, character: str) -> None:
+ """Update all properties for *character* (called once per character)."""
+ self.character = character
+
+ # ASCII fast-path: for characters with ord < 128, we can skip
+ # _character_flags() entirely and derive most properties from ord.
+ o: int = ord(character)
+ if o < 128:
+ self.is_ascii = True
+ self.accentuated = False
+ self.is_cjk = False
+ self.is_arabic = False
+ self.is_glyph = False
+ # ASCII alpha: a-z (97-122) or A-Z (65-90)
+ if 65 <= o <= 90:
+ # Uppercase ASCII letter
+ self.alpha = True
+ self.upper = True
+ self.lower = False
+ self.space = False
+ self.digit = False
+ self.printable = True
+ self.case_variable = True
+ self.flags = _LATIN
+ self.latin = True
+ self.punct = False
+ self.sym = False
+ elif 97 <= o <= 122:
+ # Lowercase ASCII letter
+ self.alpha = True
+ self.upper = False
+ self.lower = True
+ self.space = False
+ self.digit = False
+ self.printable = True
+ self.case_variable = True
+ self.flags = _LATIN
+ self.latin = True
+ self.punct = False
+ self.sym = False
+ elif 48 <= o <= 57:
+ # ASCII digit 0-9
+ self.alpha = False
+ self.upper = False
+ self.lower = False
+ self.space = False
+ self.digit = True
+ self.printable = True
+ self.case_variable = False
+ self.flags = 0
+ self.latin = False
+ self.punct = False
+ self.sym = False
+ elif o == 32 or (9 <= o <= 13):
+ # Space, tab, newline, etc.
+ self.alpha = False
+ self.upper = False
+ self.lower = False
+ self.space = True
+ self.digit = False
+ self.printable = o == 32
+ self.case_variable = False
+ self.flags = 0
+ self.latin = False
+ self.punct = False
+ self.sym = False
+ else:
+ # Other ASCII (punctuation, symbols, control chars)
+ self.printable = character.isprintable()
+ self.alpha = False
+ self.upper = False
+ self.lower = False
+ self.space = False
+ self.digit = False
+ self.case_variable = False
+ self.flags = 0
+ self.latin = False
+ self.punct = is_punctuation(character) if self.printable else False
+ self.sym = is_symbol(character) if self.printable else False
+ else:
+ # Non-ASCII path
+ self.is_ascii = False
+ self.printable = character.isprintable()
+ self.alpha = character.isalpha()
+ self.upper = character.isupper()
+ self.lower = character.islower()
+ self.space = character.isspace()
+ self.digit = character.isdigit()
+ self.case_variable = self.lower != self.upper
+
+ # Flag-based classification (single unicodedata.name() call, lru-cached)
+ flags: int
+ if self.alpha:
+ flags = _character_flags(character)
+ else:
+ flags = 0
+ self.flags = flags
+ self.accentuated = bool(flags & _ACCENTUATED)
+ self.latin = bool(flags & _LATIN)
+ self.is_cjk = bool(flags & _CJK)
+ self.is_arabic = bool(flags & _ARABIC)
+ self.is_glyph = bool(flags & _GLYPH_MASK)
+
+ # Eagerly compute punct and sym (avoids property dispatch overhead
+ # on 300K+ accesses in the hot loop).
+ self.punct = is_punctuation(character) if self.printable else False
+ self.sym = is_symbol(character) if self.printable else False
+
+
+class MessDetectorPlugin:
+ """
+ Base abstract class used for mess detection plugins.
+ All detectors MUST extend and implement given methods.
+ """
+
+ __slots__ = ()
+
+ def feed_info(self, character: str, info: CharInfo) -> None:
+ """
+ The main routine to be executed upon character.
+ Insert the logic in witch the text would be considered chaotic.
+ """
+ raise NotImplementedError # Defensive:
+
+ def reset(self) -> None: # Defensive:
+ """
+ Permit to reset the plugin to the initial state.
+ """
+ raise NotImplementedError
+
+ @property
+ def ratio(self) -> float:
+ """
+ Compute the chaos ratio based on what your feed() has seen.
+ Must NOT be lower than 0.; No restriction gt 0.
+ """
+ raise NotImplementedError # Defensive:
+
+
+@final
+class TooManySymbolOrPunctuationPlugin(MessDetectorPlugin):
+ __slots__ = (
+ "_punctuation_count",
+ "_symbol_count",
+ "_character_count",
+ "_last_printable_char",
+ "_frenzy_symbol_in_word",
+ )
+
+ def __init__(self) -> None:
+ self._punctuation_count: int = 0
+ self._symbol_count: int = 0
+ self._character_count: int = 0
+
+ self._last_printable_char: str | None = None
+ self._frenzy_symbol_in_word: bool = False
+
+ def feed_info(self, character: str, info: CharInfo) -> None:
+ """Optimized feed using pre-computed character info."""
+ self._character_count += 1
+
+ if (
+ character != self._last_printable_char
+ and character not in COMMON_SAFE_ASCII_CHARACTERS
+ ):
+ if info.punct:
+ self._punctuation_count += 1
+ elif not info.digit and info.sym and not is_emoticon(character):
+ self._symbol_count += 2
+
+ self._last_printable_char = character
+
+ def reset(self) -> None: # Abstract
+ self._punctuation_count = 0
+ self._character_count = 0
+ self._symbol_count = 0
+
+ @property
+ def ratio(self) -> float:
+ if self._character_count == 0:
+ return 0.0
+
+ ratio_of_punctuation: float = (
+ self._punctuation_count + self._symbol_count
+ ) / self._character_count
+
+ return ratio_of_punctuation if ratio_of_punctuation >= 0.3 else 0.0
+
+
+@final
+class TooManyAccentuatedPlugin(MessDetectorPlugin):
+ __slots__ = ("_character_count", "_accentuated_count")
+
+ def __init__(self) -> None:
+ self._character_count: int = 0
+ self._accentuated_count: int = 0
+
+ def feed_info(self, character: str, info: CharInfo) -> None:
+ """Optimized feed using pre-computed character info."""
+ self._character_count += 1
+
+ if info.accentuated:
+ self._accentuated_count += 1
+
+ def reset(self) -> None: # Abstract
+ self._character_count = 0
+ self._accentuated_count = 0
+
+ @property
+ def ratio(self) -> float:
+ if self._character_count < 8:
+ return 0.0
+
+ ratio_of_accentuation: float = self._accentuated_count / self._character_count
+ return ratio_of_accentuation if ratio_of_accentuation >= 0.35 else 0.0
+
+
+@final
+class UnprintablePlugin(MessDetectorPlugin):
+ __slots__ = ("_unprintable_count", "_character_count")
+
+ def __init__(self) -> None:
+ self._unprintable_count: int = 0
+ self._character_count: int = 0
+
+ def feed_info(self, character: str, info: CharInfo) -> None:
+ """Optimized feed using pre-computed character info."""
+ if (
+ not info.space
+ and not info.printable
+ and character != "\x1a"
+ and character != "\ufeff"
+ ):
+ self._unprintable_count += 1
+ self._character_count += 1
+
+ def reset(self) -> None: # Abstract
+ self._unprintable_count = 0
+
+ @property
+ def ratio(self) -> float:
+ if self._character_count == 0: # Defensive:
+ return 0.0
+
+ return (self._unprintable_count * 8) / self._character_count
+
+
+@final
+class SuspiciousDuplicateAccentPlugin(MessDetectorPlugin):
+ __slots__ = (
+ "_successive_count",
+ "_character_count",
+ "_last_latin_character",
+ "_last_was_accentuated",
+ )
+
+ def __init__(self) -> None:
+ self._successive_count: int = 0
+ self._character_count: int = 0
+
+ self._last_latin_character: str | None = None
+ self._last_was_accentuated: bool = False
+
+ def feed_info(self, character: str, info: CharInfo) -> None:
+ """Optimized feed using pre-computed character info."""
+ self._character_count += 1
+ if (
+ self._last_latin_character is not None
+ and info.accentuated
+ and self._last_was_accentuated
+ ):
+ if info.upper and self._last_latin_character.isupper():
+ self._successive_count += 1
+ if remove_accent(character) == remove_accent(self._last_latin_character):
+ self._successive_count += 1
+ self._last_latin_character = character
+ self._last_was_accentuated = info.accentuated
+
+ def reset(self) -> None: # Abstract
+ self._successive_count = 0
+ self._character_count = 0
+ self._last_latin_character = None
+ self._last_was_accentuated = False
+
+ @property
+ def ratio(self) -> float:
+ if self._character_count == 0:
+ return 0.0
+
+ return (self._successive_count * 2) / self._character_count
+
+
+@final
+class SuspiciousRange(MessDetectorPlugin):
+ __slots__ = (
+ "_suspicious_successive_range_count",
+ "_character_count",
+ "_last_printable_seen",
+ "_last_printable_range",
+ )
+
+ def __init__(self) -> None:
+ self._suspicious_successive_range_count: int = 0
+ self._character_count: int = 0
+ self._last_printable_seen: str | None = None
+ self._last_printable_range: str | None = None
+
+ def feed_info(self, character: str, info: CharInfo) -> None:
+ """Optimized feed using pre-computed character info."""
+ self._character_count += 1
+
+ if info.space or info.punct or character in COMMON_SAFE_ASCII_CHARACTERS:
+ self._last_printable_seen = None
+ self._last_printable_range = None
+ return
+
+ if self._last_printable_seen is None:
+ self._last_printable_seen = character
+ self._last_printable_range = unicode_range(character)
+ return
+
+ unicode_range_a: str | None = self._last_printable_range
+ unicode_range_b: str | None = unicode_range(character)
+
+ if is_suspiciously_successive_range(unicode_range_a, unicode_range_b):
+ self._suspicious_successive_range_count += 1
+
+ self._last_printable_seen = character
+ self._last_printable_range = unicode_range_b
+
+ def reset(self) -> None: # Abstract
+ self._character_count = 0
+ self._suspicious_successive_range_count = 0
+ self._last_printable_seen = None
+ self._last_printable_range = None
+
+ @property
+ def ratio(self) -> float:
+ if self._character_count <= 13:
+ return 0.0
+
+ ratio_of_suspicious_range_usage: float = (
+ self._suspicious_successive_range_count * 2
+ ) / self._character_count
+
+ return ratio_of_suspicious_range_usage
+
+
+@final
+class SuperWeirdWordPlugin(MessDetectorPlugin):
+ __slots__ = (
+ "_word_count",
+ "_bad_word_count",
+ "_foreign_long_count",
+ "_is_current_word_bad",
+ "_foreign_long_watch",
+ "_character_count",
+ "_bad_character_count",
+ "_buffer_length",
+ "_buffer_last_char",
+ "_buffer_last_char_accentuated",
+ "_buffer_accent_count",
+ "_buffer_glyph_count",
+ "_buffer_upper_count",
+ )
+
+ def __init__(self) -> None:
+ self._word_count: int = 0
+ self._bad_word_count: int = 0
+ self._foreign_long_count: int = 0
+
+ self._is_current_word_bad: bool = False
+ self._foreign_long_watch: bool = False
+
+ self._character_count: int = 0
+ self._bad_character_count: int = 0
+
+ self._buffer_length: int = 0
+ self._buffer_last_char: str | None = None
+ self._buffer_last_char_accentuated: bool = False
+ self._buffer_accent_count: int = 0
+ self._buffer_glyph_count: int = 0
+ self._buffer_upper_count: int = 0
+
+ def feed_info(self, character: str, info: CharInfo) -> None:
+ """Optimized feed using pre-computed character info."""
+ if info.alpha:
+ self._buffer_length += 1
+ self._buffer_last_char = character
+
+ if info.upper:
+ self._buffer_upper_count += 1
+
+ self._buffer_last_char_accentuated = info.accentuated
+
+ if info.accentuated:
+ self._buffer_accent_count += 1
+ if (
+ not self._foreign_long_watch
+ and (not info.latin or info.accentuated)
+ and not info.is_glyph
+ ):
+ self._foreign_long_watch = True
+ if info.is_glyph:
+ self._buffer_glyph_count += 1
+ return
+ if not self._buffer_length:
+ return
+ if info.space or info.punct or is_separator(character):
+ self._word_count += 1
+ buffer_length: int = self._buffer_length
+
+ self._character_count += buffer_length
+
+ if buffer_length >= 4:
+ if self._buffer_accent_count / buffer_length >= 0.5:
+ self._is_current_word_bad = True
+ elif (
+ self._buffer_last_char_accentuated
+ and self._buffer_last_char.isupper() # type: ignore[union-attr]
+ and self._buffer_upper_count != buffer_length
+ ):
+ self._foreign_long_count += 1
+ self._is_current_word_bad = True
+ elif self._buffer_glyph_count == 1:
+ self._is_current_word_bad = True
+ self._foreign_long_count += 1
+ if buffer_length >= 24 and self._foreign_long_watch:
+ probable_camel_cased: bool = (
+ self._buffer_upper_count > 0
+ and self._buffer_upper_count / buffer_length <= 0.3
+ )
+
+ if not probable_camel_cased:
+ self._foreign_long_count += 1
+ self._is_current_word_bad = True
+
+ if self._is_current_word_bad:
+ self._bad_word_count += 1
+ self._bad_character_count += buffer_length
+ self._is_current_word_bad = False
+
+ self._foreign_long_watch = False
+ self._buffer_length = 0
+ self._buffer_last_char = None
+ self._buffer_last_char_accentuated = False
+ self._buffer_accent_count = 0
+ self._buffer_glyph_count = 0
+ self._buffer_upper_count = 0
+ elif (
+ character not in {"<", ">", "-", "=", "~", "|", "_"}
+ and not info.digit
+ and info.sym
+ ):
+ self._is_current_word_bad = True
+ self._buffer_length += 1
+ self._buffer_last_char = character
+ self._buffer_last_char_accentuated = False
+
+ def reset(self) -> None: # Abstract
+ self._buffer_length = 0
+ self._buffer_last_char = None
+ self._buffer_last_char_accentuated = False
+ self._is_current_word_bad = False
+ self._foreign_long_watch = False
+ self._bad_word_count = 0
+ self._word_count = 0
+ self._character_count = 0
+ self._bad_character_count = 0
+ self._foreign_long_count = 0
+ self._buffer_accent_count = 0
+ self._buffer_glyph_count = 0
+ self._buffer_upper_count = 0
+
+ @property
+ def ratio(self) -> float:
+ if self._word_count <= 10 and self._foreign_long_count == 0:
+ return 0.0
+
+ return self._bad_character_count / self._character_count
+
+
+@final
+class CjkUncommonPlugin(MessDetectorPlugin):
+ """
+ Detect messy CJK text that probably means nothing.
+ """
+
+ __slots__ = ("_character_count", "_uncommon_count")
+
+ def __init__(self) -> None:
+ self._character_count: int = 0
+ self._uncommon_count: int = 0
+
+ def feed_info(self, character: str, info: CharInfo) -> None:
+ """Optimized feed using pre-computed character info."""
+ self._character_count += 1
+
+ if character not in COMMON_CJK_CHARACTERS:
+ self._uncommon_count += 1
+
+ def reset(self) -> None: # Abstract
+ self._character_count = 0
+ self._uncommon_count = 0
+
+ @property
+ def ratio(self) -> float:
+ if self._character_count < 8:
+ return 0.0
+
+ uncommon_form_usage: float = self._uncommon_count / self._character_count
+
+ # we can be pretty sure it's garbage when uncommon characters are widely
+ # used. otherwise it could just be traditional chinese for example.
+ return uncommon_form_usage / 10 if uncommon_form_usage > 0.5 else 0.0
+
+
+@final
+class ArchaicUpperLowerPlugin(MessDetectorPlugin):
+ __slots__ = (
+ "_buf",
+ "_character_count_since_last_sep",
+ "_successive_upper_lower_count",
+ "_successive_upper_lower_count_final",
+ "_character_count",
+ "_last_alpha_seen",
+ "_last_alpha_seen_upper",
+ "_last_alpha_seen_lower",
+ "_current_ascii_only",
+ )
+
+ def __init__(self) -> None:
+ self._buf: bool = False
+
+ self._character_count_since_last_sep: int = 0
+
+ self._successive_upper_lower_count: int = 0
+ self._successive_upper_lower_count_final: int = 0
+
+ self._character_count: int = 0
+
+ self._last_alpha_seen: str | None = None
+ self._last_alpha_seen_upper: bool = False
+ self._last_alpha_seen_lower: bool = False
+ self._current_ascii_only: bool = True
+
+ def feed_info(self, character: str, info: CharInfo) -> None:
+ """Optimized feed using pre-computed character info."""
+ is_concerned: bool = info.alpha and info.case_variable
+ chunk_sep: bool = not is_concerned
+
+ if chunk_sep and self._character_count_since_last_sep > 0:
+ if (
+ self._character_count_since_last_sep <= 64
+ and not info.digit
+ and not self._current_ascii_only
+ ):
+ self._successive_upper_lower_count_final += (
+ self._successive_upper_lower_count
+ )
+
+ self._successive_upper_lower_count = 0
+ self._character_count_since_last_sep = 0
+ self._last_alpha_seen = None
+ self._buf = False
+ self._character_count += 1
+ self._current_ascii_only = True
+
+ return
+
+ if self._current_ascii_only and not info.is_ascii:
+ self._current_ascii_only = False
+
+ if self._last_alpha_seen is not None:
+ if (info.upper and self._last_alpha_seen_lower) or (
+ info.lower and self._last_alpha_seen_upper
+ ):
+ if self._buf:
+ self._successive_upper_lower_count += 2
+ self._buf = False
+ else:
+ self._buf = True
+ else:
+ self._buf = False
+
+ self._character_count += 1
+ self._character_count_since_last_sep += 1
+ self._last_alpha_seen = character
+ self._last_alpha_seen_upper = info.upper
+ self._last_alpha_seen_lower = info.lower
+
+ def reset(self) -> None: # Abstract
+ self._character_count = 0
+ self._character_count_since_last_sep = 0
+ self._successive_upper_lower_count = 0
+ self._successive_upper_lower_count_final = 0
+ self._last_alpha_seen = None
+ self._last_alpha_seen_upper = False
+ self._last_alpha_seen_lower = False
+ self._buf = False
+ self._current_ascii_only = True
+
+ @property
+ def ratio(self) -> float:
+ if self._character_count == 0: # Defensive:
+ return 0.0
+
+ return self._successive_upper_lower_count_final / self._character_count
+
+
+@final
+class ArabicIsolatedFormPlugin(MessDetectorPlugin):
+ __slots__ = ("_character_count", "_isolated_form_count")
+
+ def __init__(self) -> None:
+ self._character_count: int = 0
+ self._isolated_form_count: int = 0
+
+ def reset(self) -> None: # Abstract
+ self._character_count = 0
+ self._isolated_form_count = 0
+
+ def feed_info(self, character: str, info: CharInfo) -> None:
+ """Optimized feed using pre-computed character info."""
+ self._character_count += 1
+
+ if info.flags & _ARABIC_ISOLATED_FORM:
+ self._isolated_form_count += 1
+
+ @property
+ def ratio(self) -> float:
+ if self._character_count < 8:
+ return 0.0
+
+ isolated_form_usage: float = self._isolated_form_count / self._character_count
+
+ return isolated_form_usage
+
+
+@lru_cache(maxsize=1024)
+def is_suspiciously_successive_range(
+ unicode_range_a: str | None, unicode_range_b: str | None
+) -> bool:
+ """
+ Determine if two Unicode range seen next to each other can be considered as suspicious.
+ """
+ if unicode_range_a is None or unicode_range_b is None:
+ return True
+
+ if unicode_range_a == unicode_range_b:
+ return False
+
+ if "Latin" in unicode_range_a and "Latin" in unicode_range_b:
+ return False
+
+ if "Emoticons" in unicode_range_a or "Emoticons" in unicode_range_b:
+ return False
+
+ # Latin characters can be accompanied with a combining diacritical mark
+ # eg. Vietnamese.
+ if ("Latin" in unicode_range_a or "Latin" in unicode_range_b) and (
+ "Combining" in unicode_range_a or "Combining" in unicode_range_b
+ ):
+ return False
+
+ keywords_range_a, keywords_range_b = (
+ unicode_range_a.split(" "),
+ unicode_range_b.split(" "),
+ )
+
+ for el in keywords_range_a:
+ if el in UNICODE_SECONDARY_RANGE_KEYWORD:
+ continue
+ if el in keywords_range_b:
+ return False
+
+ # Japanese Exception
+ range_a_jp_chars, range_b_jp_chars = (
+ unicode_range_a
+ in (
+ "Hiragana",
+ "Katakana",
+ ),
+ unicode_range_b in ("Hiragana", "Katakana"),
+ )
+ if (range_a_jp_chars or range_b_jp_chars) and (
+ "CJK" in unicode_range_a or "CJK" in unicode_range_b
+ ):
+ return False
+ if range_a_jp_chars and range_b_jp_chars:
+ return False
+
+ if "Hangul" in unicode_range_a or "Hangul" in unicode_range_b:
+ if "CJK" in unicode_range_a or "CJK" in unicode_range_b:
+ return False
+ if unicode_range_a == "Basic Latin" or unicode_range_b == "Basic Latin":
+ return False
+
+ # Chinese/Japanese use dedicated range for punctuation and/or separators.
+ if ("CJK" in unicode_range_a or "CJK" in unicode_range_b) or (
+ unicode_range_a in ["Katakana", "Hiragana"]
+ and unicode_range_b in ["Katakana", "Hiragana"]
+ ):
+ if "Punctuation" in unicode_range_a or "Punctuation" in unicode_range_b:
+ return False
+ if "Forms" in unicode_range_a or "Forms" in unicode_range_b:
+ return False
+ if unicode_range_a == "Basic Latin" or unicode_range_b == "Basic Latin":
+ return False
+
+ return True
+
+
+@lru_cache(maxsize=2048)
+def mess_ratio(
+ decoded_sequence: str, maximum_threshold: float = 0.2, debug: bool = False
+) -> float:
+ """
+ Compute a mess ratio given a decoded bytes sequence. The maximum threshold does stop the computation earlier.
+ """
+
+ seq_len: int = len(decoded_sequence)
+
+ if seq_len < 511:
+ step: int = 32
+ elif seq_len < 1024:
+ step = 64
+ else:
+ step = 128
+
+ # Create each detector as a named local variable (unrolled from the generic loop).
+ # This eliminates per-character iteration over the detector list and
+ # per-character eligible() virtual dispatch, while keeping every plugin class
+ # intact and fully readable.
+ d_sp: TooManySymbolOrPunctuationPlugin = TooManySymbolOrPunctuationPlugin()
+ d_ta: TooManyAccentuatedPlugin = TooManyAccentuatedPlugin()
+ d_up: UnprintablePlugin = UnprintablePlugin()
+ d_sda: SuspiciousDuplicateAccentPlugin = SuspiciousDuplicateAccentPlugin()
+ d_sr: SuspiciousRange = SuspiciousRange()
+ d_sw: SuperWeirdWordPlugin = SuperWeirdWordPlugin()
+ d_cu: CjkUncommonPlugin = CjkUncommonPlugin()
+ d_au: ArchaicUpperLowerPlugin = ArchaicUpperLowerPlugin()
+ d_ai: ArabicIsolatedFormPlugin = ArabicIsolatedFormPlugin()
+
+ # Local references for feed_info methods called in the hot loop.
+ d_sp_feed = d_sp.feed_info
+ d_ta_feed = d_ta.feed_info
+ d_up_feed = d_up.feed_info
+ d_sda_feed = d_sda.feed_info
+ d_sr_feed = d_sr.feed_info
+ d_sw_feed = d_sw.feed_info
+ d_cu_feed = d_cu.feed_info
+ d_au_feed = d_au.feed_info
+ d_ai_feed = d_ai.feed_info
+
+ # Single reusable CharInfo object (avoids per-character allocation).
+ info: CharInfo = CharInfo()
+ info_update = info.update
+
+ mean_mess_ratio: float
+
+ for block_start in range(0, seq_len, step):
+ for character in decoded_sequence[block_start : block_start + step]:
+ # Pre-compute all character properties once (shared across all plugins).
+ info_update(character)
+
+ # Detectors with eligible() == always True
+ d_up_feed(character, info)
+ d_sw_feed(character, info)
+ d_au_feed(character, info)
+
+ # Detectors with eligible() == isprintable
+ if info.printable:
+ d_sp_feed(character, info)
+ d_sr_feed(character, info)
+
+ # Detectors with eligible() == isalpha
+ if info.alpha:
+ d_ta_feed(character, info)
+ # SuspiciousDuplicateAccent: isalpha() and is_latin()
+ if info.latin:
+ d_sda_feed(character, info)
+ # CjkUncommon: is_cjk()
+ if info.is_cjk:
+ d_cu_feed(character, info)
+ # ArabicIsolatedForm: is_arabic()
+ if info.is_arabic:
+ d_ai_feed(character, info)
+
+ mean_mess_ratio = (
+ d_sp.ratio
+ + d_ta.ratio
+ + d_up.ratio
+ + d_sda.ratio
+ + d_sr.ratio
+ + d_sw.ratio
+ + d_cu.ratio
+ + d_au.ratio
+ + d_ai.ratio
+ )
+
+ if mean_mess_ratio >= maximum_threshold:
+ break
+ else:
+ # Flush last word buffer in SuperWeirdWordPlugin via trailing newline.
+ info_update("\n")
+ d_sw_feed("\n", info)
+ d_au_feed("\n", info)
+ d_up_feed("\n", info)
+
+ mean_mess_ratio = (
+ d_sp.ratio
+ + d_ta.ratio
+ + d_up.ratio
+ + d_sda.ratio
+ + d_sr.ratio
+ + d_sw.ratio
+ + d_cu.ratio
+ + d_au.ratio
+ + d_ai.ratio
+ )
+
+ if debug: # Defensive:
+ logger = getLogger("charset_normalizer")
+
+ logger.log(
+ TRACE,
+ "Mess-detector extended-analysis start. "
+ f"intermediary_mean_mess_ratio_calc={step} mean_mess_ratio={mean_mess_ratio} "
+ f"maximum_threshold={maximum_threshold}",
+ )
+
+ if seq_len > 16:
+ logger.log(TRACE, f"Starting with: {decoded_sequence[:16]}")
+ logger.log(TRACE, f"Ending with: {decoded_sequence[-16::]}")
+
+ for dt in [d_sp, d_ta, d_up, d_sda, d_sr, d_sw, d_cu, d_au, d_ai]:
+ logger.log(TRACE, f"{dt.__class__}: {dt.ratio}")
+
+ return round(mean_mess_ratio, 3)
diff --git a/python/user_packages/Python313/site-packages/charset_normalizer/models.py b/python/user_packages/Python313/site-packages/charset_normalizer/models.py
new file mode 100644
index 0000000000000000000000000000000000000000..5d1d5aa45b5814d3deb775aed9eb18726d2d0e44
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/charset_normalizer/models.py
@@ -0,0 +1,369 @@
+from __future__ import annotations
+
+from encodings.aliases import aliases
+from json import dumps
+from re import sub
+from typing import Any, Iterator, List, Tuple
+
+from .constant import RE_POSSIBLE_ENCODING_INDICATION, TOO_BIG_SEQUENCE
+from .utils import iana_name, is_multi_byte_encoding, unicode_range
+
+
+class CharsetMatch:
+ def __init__(
+ self,
+ payload: bytes | bytearray,
+ guessed_encoding: str,
+ mean_mess_ratio: float,
+ has_sig_or_bom: bool,
+ languages: CoherenceMatches,
+ decoded_payload: str | None = None,
+ preemptive_declaration: str | None = None,
+ ):
+ self._payload: bytes | bytearray = payload
+
+ self._encoding: str = guessed_encoding
+ self._mean_mess_ratio: float = mean_mess_ratio
+ self._languages: CoherenceMatches = languages
+ self._has_sig_or_bom: bool = has_sig_or_bom
+ self._unicode_ranges: list[str] | None = None
+
+ self._leaves: list[CharsetMatch] = []
+ self._mean_coherence_ratio: float = 0.0
+
+ self._output_payload: bytes | None = None
+ self._output_encoding: str | None = None
+
+ self._string: str | None = decoded_payload
+
+ self._preemptive_declaration: str | None = preemptive_declaration
+
+ def __eq__(self, other: object) -> bool:
+ if not isinstance(other, CharsetMatch):
+ if isinstance(other, str):
+ return iana_name(other) == self.encoding
+ return False
+ return self.encoding == other.encoding and self.fingerprint == other.fingerprint
+
+ def __lt__(self, other: object) -> bool:
+ """
+ Implemented to make sorted available upon CharsetMatches items.
+ """
+ if not isinstance(other, CharsetMatch):
+ raise ValueError
+
+ chaos_difference: float = abs(self.chaos - other.chaos)
+ coherence_difference: float = abs(self.coherence - other.coherence)
+
+ # Below 0.5% difference --> Use Coherence
+ if chaos_difference < 0.005 and coherence_difference > 0.02:
+ return self.coherence > other.coherence
+ elif chaos_difference < 0.005 and coherence_difference <= 0.02:
+ # When having a difficult decision, use the result that decoded as many multi-byte as possible.
+ # preserve RAM usage!
+ if len(self._payload) >= TOO_BIG_SEQUENCE:
+ return self.chaos < other.chaos
+ return self.multi_byte_usage > other.multi_byte_usage
+
+ return self.chaos < other.chaos
+
+ @property
+ def multi_byte_usage(self) -> float:
+ return 1.0 - (len(str(self)) / len(self.raw))
+
+ def __str__(self) -> str:
+ # Lazy Str Loading
+ if self._string is None:
+ self._string = str(self._payload, self._encoding, "strict")
+ # UTF-7 BOM is encoded in modified Base64 whose byte boundary
+ # can overlap with the next character, so raw-byte stripping
+ # is unreliable. Strip the decoded BOM character instead.
+ if (
+ self._has_sig_or_bom
+ and self._encoding == "utf_7"
+ and self._string
+ and self._string[0] == "\ufeff"
+ ):
+ self._string = self._string[1:]
+ return self._string
+
+ def __repr__(self) -> str:
+ return f""
+
+ def add_submatch(self, other: CharsetMatch) -> None:
+ if not isinstance(other, CharsetMatch) or other == self:
+ raise ValueError(
+ "Unable to add instance <{}> as a submatch of a CharsetMatch".format(
+ other.__class__
+ )
+ )
+
+ other._string = None # Unload RAM usage; dirty trick.
+ self._leaves.append(other)
+
+ @property
+ def encoding(self) -> str:
+ return self._encoding
+
+ @property
+ def encoding_aliases(self) -> list[str]:
+ """
+ Encoding name are known by many name, using this could help when searching for IBM855 when it's listed as CP855.
+ """
+ also_known_as: list[str] = []
+ for u, p in aliases.items():
+ if self.encoding == u:
+ also_known_as.append(p)
+ elif self.encoding == p:
+ also_known_as.append(u)
+ return also_known_as
+
+ @property
+ def bom(self) -> bool:
+ return self._has_sig_or_bom
+
+ @property
+ def byte_order_mark(self) -> bool:
+ return self._has_sig_or_bom
+
+ @property
+ def languages(self) -> list[str]:
+ """
+ Return the complete list of possible languages found in decoded sequence.
+ Usually not really useful. Returned list may be empty even if 'language' property return something != 'Unknown'.
+ """
+ return [e[0] for e in self._languages]
+
+ @property
+ def language(self) -> str:
+ """
+ Most probable language found in decoded sequence. If none were detected or inferred, the property will return
+ "Unknown".
+ """
+ if not self._languages:
+ # Trying to infer the language based on the given encoding
+ # Its either English or we should not pronounce ourselves in certain cases.
+ if "ascii" in self.could_be_from_charset:
+ return "English"
+
+ # doing it there to avoid circular import
+ from charset_normalizer.cd import encoding_languages, mb_encoding_languages
+
+ languages = (
+ mb_encoding_languages(self.encoding)
+ if is_multi_byte_encoding(self.encoding)
+ else encoding_languages(self.encoding)
+ )
+
+ if len(languages) == 0 or "Latin Based" in languages:
+ return "Unknown"
+
+ return languages[0]
+
+ return self._languages[0][0]
+
+ @property
+ def chaos(self) -> float:
+ return self._mean_mess_ratio
+
+ @property
+ def coherence(self) -> float:
+ if not self._languages:
+ return 0.0
+ return self._languages[0][1]
+
+ @property
+ def percent_chaos(self) -> float:
+ return round(self.chaos * 100, ndigits=3)
+
+ @property
+ def percent_coherence(self) -> float:
+ return round(self.coherence * 100, ndigits=3)
+
+ @property
+ def raw(self) -> bytes | bytearray:
+ """
+ Original untouched bytes.
+ """
+ return self._payload
+
+ @property
+ def submatch(self) -> list[CharsetMatch]:
+ return self._leaves
+
+ @property
+ def has_submatch(self) -> bool:
+ return len(self._leaves) > 0
+
+ @property
+ def alphabets(self) -> list[str]:
+ if self._unicode_ranges is not None:
+ return self._unicode_ranges
+ # list detected ranges
+ detected_ranges: list[str | None] = [unicode_range(char) for char in str(self)]
+ # filter and sort
+ self._unicode_ranges = sorted(list({r for r in detected_ranges if r}))
+ return self._unicode_ranges
+
+ @property
+ def could_be_from_charset(self) -> list[str]:
+ """
+ The complete list of encoding that output the exact SAME str result and therefore could be the originating
+ encoding.
+ This list does include the encoding available in property 'encoding'.
+ """
+ return [self._encoding] + [m.encoding for m in self._leaves]
+
+ def output(self, encoding: str = "utf_8") -> bytes:
+ """
+ Method to get re-encoded bytes payload using given target encoding. Default to UTF-8.
+ Any errors will be simply ignored by the encoder NOT replaced.
+ """
+ if self._output_encoding is None or self._output_encoding != encoding:
+ self._output_encoding = encoding
+ decoded_string = str(self)
+ if (
+ self._preemptive_declaration is not None
+ and self._preemptive_declaration.lower()
+ not in ["utf-8", "utf8", "utf_8"]
+ ):
+ patched_header = sub(
+ RE_POSSIBLE_ENCODING_INDICATION,
+ lambda m: m.string[m.span()[0] : m.span()[1]].replace(
+ m.groups()[0],
+ iana_name(self._output_encoding).replace("_", "-"), # type: ignore[arg-type]
+ ),
+ decoded_string[:8192],
+ count=1,
+ )
+
+ decoded_string = patched_header + decoded_string[8192:]
+
+ self._output_payload = decoded_string.encode(encoding, "replace")
+
+ return self._output_payload # type: ignore
+
+ @property
+ def fingerprint(self) -> int:
+ """
+ Retrieve a hash fingerprint of the decoded payload, used for deduplication.
+ """
+ return hash(str(self))
+
+
+class CharsetMatches:
+ """
+ Container with every CharsetMatch items ordered by default from most probable to the less one.
+ Act like a list(iterable) but does not implements all related methods.
+ """
+
+ def __init__(self, results: list[CharsetMatch] | None = None):
+ self._results: list[CharsetMatch] = sorted(results) if results else []
+
+ def __iter__(self) -> Iterator[CharsetMatch]:
+ yield from self._results
+
+ def __getitem__(self, item: int | str) -> CharsetMatch:
+ """
+ Retrieve a single item either by its position or encoding name (alias may be used here).
+ Raise KeyError upon invalid index or encoding not present in results.
+ """
+ if isinstance(item, int):
+ return self._results[item]
+ if isinstance(item, str):
+ item = iana_name(item, False)
+ for result in self._results:
+ if item in result.could_be_from_charset:
+ return result
+ raise KeyError
+
+ def __len__(self) -> int:
+ return len(self._results)
+
+ def __bool__(self) -> bool:
+ return len(self._results) > 0
+
+ def append(self, item: CharsetMatch) -> None:
+ """
+ Insert a single match. Will be inserted accordingly to preserve sort.
+ Can be inserted as a submatch.
+ """
+ if not isinstance(item, CharsetMatch):
+ raise ValueError(
+ "Cannot append instance '{}' to CharsetMatches".format(
+ str(item.__class__)
+ )
+ )
+ # We should disable the submatch factoring when the input file is too heavy (conserve RAM usage)
+ if len(item.raw) < TOO_BIG_SEQUENCE:
+ for match in self._results:
+ if match.fingerprint == item.fingerprint and match.chaos == item.chaos:
+ match.add_submatch(item)
+ return
+ self._results.append(item)
+ self._results = sorted(self._results)
+
+ def best(self) -> CharsetMatch | None:
+ """
+ Simply return the first match. Strict equivalent to matches[0].
+ """
+ if not self._results:
+ return None
+ return self._results[0]
+
+ def first(self) -> CharsetMatch | None:
+ """
+ Redundant method, call the method best(). Kept for BC reasons.
+ """
+ return self.best()
+
+
+CoherenceMatch = Tuple[str, float]
+CoherenceMatches = List[CoherenceMatch]
+
+
+class CliDetectionResult:
+ def __init__(
+ self,
+ path: str,
+ encoding: str | None,
+ encoding_aliases: list[str],
+ alternative_encodings: list[str],
+ language: str,
+ alphabets: list[str],
+ has_sig_or_bom: bool,
+ chaos: float,
+ coherence: float,
+ unicode_path: str | None,
+ is_preferred: bool,
+ ):
+ self.path: str = path
+ self.unicode_path: str | None = unicode_path
+ self.encoding: str | None = encoding
+ self.encoding_aliases: list[str] = encoding_aliases
+ self.alternative_encodings: list[str] = alternative_encodings
+ self.language: str = language
+ self.alphabets: list[str] = alphabets
+ self.has_sig_or_bom: bool = has_sig_or_bom
+ self.chaos: float = chaos
+ self.coherence: float = coherence
+ self.is_preferred: bool = is_preferred
+
+ @property
+ def __dict__(self) -> dict[str, Any]: # type: ignore
+ return {
+ "path": self.path,
+ "encoding": self.encoding,
+ "encoding_aliases": self.encoding_aliases,
+ "alternative_encodings": self.alternative_encodings,
+ "language": self.language,
+ "alphabets": self.alphabets,
+ "has_sig_or_bom": self.has_sig_or_bom,
+ "chaos": self.chaos,
+ "coherence": self.coherence,
+ "unicode_path": self.unicode_path,
+ "is_preferred": self.is_preferred,
+ }
+
+ def to_json(self) -> str:
+ return dumps(self.__dict__, ensure_ascii=True, indent=4)
diff --git a/python/user_packages/Python313/site-packages/charset_normalizer/py.typed b/python/user_packages/Python313/site-packages/charset_normalizer/py.typed
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/python/user_packages/Python313/site-packages/charset_normalizer/utils.py b/python/user_packages/Python313/site-packages/charset_normalizer/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..1537a6f02e09c0f07cbe828b01e5527161e21d53
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/charset_normalizer/utils.py
@@ -0,0 +1,422 @@
+from __future__ import annotations
+
+import importlib
+import logging
+import unicodedata
+from bisect import bisect_right
+from codecs import IncrementalDecoder
+from encodings.aliases import aliases
+from functools import lru_cache
+from re import findall
+from typing import Generator
+
+from _multibytecodec import ( # type: ignore[import-not-found,import]
+ MultibyteIncrementalDecoder,
+)
+
+from .constant import (
+ ENCODING_MARKS,
+ IANA_SUPPORTED_SIMILAR,
+ RE_POSSIBLE_ENCODING_INDICATION,
+ UNICODE_RANGES_COMBINED,
+ UNICODE_SECONDARY_RANGE_KEYWORD,
+ UTF8_MAXIMAL_ALLOCATION,
+ COMMON_CJK_CHARACTERS,
+ _LATIN,
+ _CJK,
+ _HANGUL,
+ _KATAKANA,
+ _HIRAGANA,
+ _THAI,
+ _ARABIC,
+ _ARABIC_ISOLATED_FORM,
+ _ACCENT_KEYWORDS,
+ _ACCENTUATED,
+)
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def _character_flags(character: str) -> int:
+ """Compute all name-based classification flags with a single unicodedata.name() call."""
+ try:
+ desc: str = unicodedata.name(character)
+ except ValueError:
+ return 0
+
+ flags: int = 0
+
+ if "LATIN" in desc:
+ flags |= _LATIN
+ if "CJK" in desc:
+ flags |= _CJK
+ if "HANGUL" in desc:
+ flags |= _HANGUL
+ if "KATAKANA" in desc:
+ flags |= _KATAKANA
+ if "HIRAGANA" in desc:
+ flags |= _HIRAGANA
+ if "THAI" in desc:
+ flags |= _THAI
+ if "ARABIC" in desc:
+ flags |= _ARABIC
+ if "ISOLATED FORM" in desc:
+ flags |= _ARABIC_ISOLATED_FORM
+
+ for kw in _ACCENT_KEYWORDS:
+ if kw in desc:
+ flags |= _ACCENTUATED
+ break
+
+ return flags
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_accentuated(character: str) -> bool:
+ return bool(_character_flags(character) & _ACCENTUATED)
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def remove_accent(character: str) -> str:
+ decomposed: str = unicodedata.decomposition(character)
+ if not decomposed:
+ return character
+
+ codes: list[str] = decomposed.split(" ")
+
+ return chr(int(codes[0], 16))
+
+
+# Pre-built sorted lookup table for O(log n) binary search in unicode_range().
+# Each entry is (range_start, range_end_exclusive, range_name).
+_UNICODE_RANGES_SORTED: list[tuple[int, int, str]] = sorted(
+ (ord_range.start, ord_range.stop, name)
+ for name, ord_range in UNICODE_RANGES_COMBINED.items()
+)
+_UNICODE_RANGE_STARTS: list[int] = [e[0] for e in _UNICODE_RANGES_SORTED]
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def unicode_range(character: str) -> str | None:
+ """
+ Retrieve the Unicode range official name from a single character.
+ """
+ character_ord: int = ord(character)
+
+ # Binary search: find the rightmost range whose start <= character_ord
+ idx = bisect_right(_UNICODE_RANGE_STARTS, character_ord) - 1
+ if idx >= 0:
+ start, stop, name = _UNICODE_RANGES_SORTED[idx]
+ if character_ord < stop:
+ return name
+
+ return None
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_latin(character: str) -> bool:
+ return bool(_character_flags(character) & _LATIN)
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_punctuation(character: str) -> bool:
+ character_category: str = unicodedata.category(character)
+
+ if "P" in character_category:
+ return True
+
+ character_range: str | None = unicode_range(character)
+
+ if character_range is None:
+ return False
+
+ return "Punctuation" in character_range
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_symbol(character: str) -> bool:
+ character_category: str = unicodedata.category(character)
+
+ if "S" in character_category or "N" in character_category:
+ return True
+
+ character_range: str | None = unicode_range(character)
+
+ if character_range is None:
+ return False
+
+ return "Forms" in character_range and character_category != "Lo"
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_emoticon(character: str) -> bool:
+ character_range: str | None = unicode_range(character)
+
+ if character_range is None:
+ return False
+
+ return "Emoticons" in character_range or "Pictographs" in character_range
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_separator(character: str) -> bool:
+ if character.isspace() or character in {"｜", "+", "<", ">"}:
+ return True
+
+ character_category: str = unicodedata.category(character)
+
+ return "Z" in character_category or character_category in {"Po", "Pd", "Pc"}
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_case_variable(character: str) -> bool:
+ return character.islower() != character.isupper()
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_cjk(character: str) -> bool:
+ return bool(_character_flags(character) & _CJK)
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_hiragana(character: str) -> bool:
+ return bool(_character_flags(character) & _HIRAGANA)
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_katakana(character: str) -> bool:
+ return bool(_character_flags(character) & _KATAKANA)
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_hangul(character: str) -> bool:
+ return bool(_character_flags(character) & _HANGUL)
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_thai(character: str) -> bool:
+ return bool(_character_flags(character) & _THAI)
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_arabic(character: str) -> bool:
+ return bool(_character_flags(character) & _ARABIC)
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_arabic_isolated_form(character: str) -> bool:
+ return bool(_character_flags(character) & _ARABIC_ISOLATED_FORM)
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_cjk_uncommon(character: str) -> bool:
+ return character not in COMMON_CJK_CHARACTERS
+
+
+@lru_cache(maxsize=len(UNICODE_RANGES_COMBINED))
+def is_unicode_range_secondary(range_name: str) -> bool:
+ return any(keyword in range_name for keyword in UNICODE_SECONDARY_RANGE_KEYWORD)
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_unprintable(character: str) -> bool:
+ return (
+ character.isspace() is False # includes \n \t \r \v
+ and character.isprintable() is False
+ and character != "\x1a" # Why? Its the ASCII substitute character.
+ and character != "\ufeff" # bug discovered in Python,
+ # Zero Width No-Break Space located in Arabic Presentation Forms-B, Unicode 1.1 not acknowledged as space.
+ )
+
+
+def any_specified_encoding(
+ sequence: bytes | bytearray, search_zone: int = 8192
+) -> str | None:
+ """
+ Extract using ASCII-only decoder any specified encoding in the first n-bytes.
+ """
+ if not isinstance(sequence, (bytes, bytearray)):
+ raise TypeError
+
+ seq_len: int = len(sequence)
+
+ results: list[str] = findall(
+ RE_POSSIBLE_ENCODING_INDICATION,
+ sequence[: min(seq_len, search_zone)].decode("ascii", errors="ignore"),
+ )
+
+ if len(results) == 0:
+ return None
+
+ for specified_encoding in results:
+ specified_encoding = specified_encoding.lower().replace("-", "_")
+
+ encoding_alias: str
+ encoding_iana: str
+
+ for encoding_alias, encoding_iana in aliases.items():
+ if encoding_alias == specified_encoding:
+ return encoding_iana
+ if encoding_iana == specified_encoding:
+ return encoding_iana
+
+ return None
+
+
+@lru_cache(maxsize=128)
+def is_multi_byte_encoding(name: str) -> bool:
+ """
+ Verify is a specific encoding is a multi byte one based on it IANA name
+ """
+ return name in {
+ "utf_8",
+ "utf_8_sig",
+ "utf_16",
+ "utf_16_be",
+ "utf_16_le",
+ "utf_32",
+ "utf_32_le",
+ "utf_32_be",
+ "utf_7",
+ } or issubclass(
+ importlib.import_module(f"encodings.{name}").IncrementalDecoder,
+ MultibyteIncrementalDecoder,
+ )
+
+
+def identify_sig_or_bom(sequence: bytes | bytearray) -> tuple[str | None, bytes]:
+ """
+ Identify and extract SIG/BOM in given sequence.
+ """
+
+ for iana_encoding in ENCODING_MARKS:
+ marks: bytes | list[bytes] = ENCODING_MARKS[iana_encoding]
+
+ if isinstance(marks, bytes):
+ marks = [marks]
+
+ for mark in marks:
+ if sequence.startswith(mark):
+ return iana_encoding, mark
+
+ return None, b""
+
+
+def should_strip_sig_or_bom(iana_encoding: str) -> bool:
+ return iana_encoding not in {"utf_16", "utf_32"}
+
+
+def iana_name(cp_name: str, strict: bool = True) -> str:
+ """Returns the Python normalized encoding name (Not the IANA official name)."""
+ cp_name = cp_name.lower().replace("-", "_")
+
+ encoding_alias: str
+ encoding_iana: str
+
+ for encoding_alias, encoding_iana in aliases.items():
+ if cp_name in [encoding_alias, encoding_iana]:
+ return encoding_iana
+
+ if strict:
+ raise ValueError(f"Unable to retrieve IANA for '{cp_name}'")
+
+ return cp_name
+
+
+def cp_similarity(iana_name_a: str, iana_name_b: str) -> float:
+ if is_multi_byte_encoding(iana_name_a) or is_multi_byte_encoding(iana_name_b):
+ return 0.0
+
+ decoder_a = importlib.import_module(f"encodings.{iana_name_a}").IncrementalDecoder
+ decoder_b = importlib.import_module(f"encodings.{iana_name_b}").IncrementalDecoder
+
+ id_a: IncrementalDecoder = decoder_a(errors="ignore")
+ id_b: IncrementalDecoder = decoder_b(errors="ignore")
+
+ character_match_count: int = 0
+
+ for i in range(256):
+ to_be_decoded: bytes = bytes([i])
+ if id_a.decode(to_be_decoded) == id_b.decode(to_be_decoded):
+ character_match_count += 1
+
+ return character_match_count / 256
+
+
+def is_cp_similar(iana_name_a: str, iana_name_b: str) -> bool:
+ """
+ Determine if two code page are at least 80% similar. IANA_SUPPORTED_SIMILAR dict was generated using
+ the function cp_similarity.
+ """
+ return (
+ iana_name_a in IANA_SUPPORTED_SIMILAR
+ and iana_name_b in IANA_SUPPORTED_SIMILAR[iana_name_a]
+ )
+
+
+def set_logging_handler(
+ name: str = "charset_normalizer",
+ level: int = logging.INFO,
+ format_string: str = "%(asctime)s | %(levelname)s | %(message)s",
+) -> None:
+ logger = logging.getLogger(name)
+ logger.setLevel(level)
+
+ handler = logging.StreamHandler()
+ handler.setFormatter(logging.Formatter(format_string))
+ logger.addHandler(handler)
+
+
+def cut_sequence_chunks(
+ sequences: bytes | bytearray,
+ encoding_iana: str,
+ offsets: range,
+ chunk_size: int,
+ bom_or_sig_available: bool,
+ strip_sig_or_bom: bool,
+ sig_payload: bytes,
+ is_multi_byte_decoder: bool,
+ decoded_payload: str | None = None,
+) -> Generator[str, None, None]:
+ if decoded_payload and is_multi_byte_decoder is False:
+ for i in offsets:
+ chunk = decoded_payload[i : i + chunk_size]
+ if not chunk:
+ break
+ yield chunk
+ else:
+ for i in offsets:
+ chunk_end = i + chunk_size
+ if chunk_end > len(sequences) + 8:
+ continue
+
+ cut_sequence = sequences[i : i + chunk_size]
+
+ if bom_or_sig_available and strip_sig_or_bom is False:
+ cut_sequence = sig_payload + cut_sequence
+
+ chunk = cut_sequence.decode(
+ encoding_iana,
+ errors="ignore" if is_multi_byte_decoder else "strict",
+ )
+
+ # multi-byte bad cutting detector and adjustment
+ # not the cleanest way to perform that fix but clever enough for now.
+ if is_multi_byte_decoder and i > 0:
+ chunk_partial_size_chk: int = min(chunk_size, 16)
+
+ if (
+ decoded_payload
+ and chunk[:chunk_partial_size_chk] not in decoded_payload
+ ):
+ for j in range(i, i - 4, -1):
+ cut_sequence = sequences[j:chunk_end]
+
+ if bom_or_sig_available and strip_sig_or_bom is False:
+ cut_sequence = sig_payload + cut_sequence
+
+ chunk = cut_sequence.decode(encoding_iana, errors="ignore")
+
+ if chunk[:chunk_partial_size_chk] in decoded_payload:
+ break
+
+ yield chunk
diff --git a/python/user_packages/Python313/site-packages/charset_normalizer/version.py b/python/user_packages/Python313/site-packages/charset_normalizer/version.py
new file mode 100644
index 0000000000000000000000000000000000000000..ae4b8895407a9e2d68f83f9b1c191725cea2a2b1
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/charset_normalizer/version.py
@@ -0,0 +1,8 @@
+"""
+Expose version
+"""
+
+from __future__ import annotations
+
+__version__ = "3.4.7"
+VERSION = __version__.split(".")
diff --git a/python/user_packages/Python313/site-packages/chromadb-1.5.9.dist-info/INSTALLER b/python/user_packages/Python313/site-packages/chromadb-1.5.9.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/chromadb-1.5.9.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/python/user_packages/Python313/site-packages/chromadb-1.5.9.dist-info/METADATA b/python/user_packages/Python313/site-packages/chromadb-1.5.9.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..602377783f666d373b67c4b3ab432989b9eb93dc
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/chromadb-1.5.9.dist-info/METADATA
@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: chromadb
+Version: 1.5.9
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Dist: build>=1.0.3
+Requires-Dist: pydantic>=2.0
+Requires-Dist: pydantic-settings>=2.0
+Requires-Dist: pybase64>=1.4.1
+Requires-Dist: uvicorn[standard]>=0.18.3
+Requires-Dist: numpy>=1.22.5
+Requires-Dist: typing-extensions>=4.5.0
+Requires-Dist: onnxruntime>=1.14.1
+Requires-Dist: opentelemetry-api>=1.2.0
+Requires-Dist: opentelemetry-exporter-otlp-proto-grpc>=1.2.0
+Requires-Dist: opentelemetry-sdk>=1.2.0
+Requires-Dist: tokenizers>=0.13.2
+Requires-Dist: pypika>=0.48.9
+Requires-Dist: tqdm>=4.65.0
+Requires-Dist: overrides>=7.3.1
+Requires-Dist: importlib-resources
+Requires-Dist: graphlib-backport>=1.0.3 ; python_full_version < '3.9'
+Requires-Dist: grpcio>=1.58.0
+Requires-Dist: bcrypt>=4.0.1
+Requires-Dist: typer>=0.9.0
+Requires-Dist: kubernetes>=28.1.0
+Requires-Dist: tenacity>=8.2.3
+Requires-Dist: pyyaml>=6.0.0
+Requires-Dist: mmh3>=4.0.1
+Requires-Dist: orjson>=3.9.12
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: rich>=10.11.0
+Requires-Dist: jsonschema>=4.19.0
+Requires-Dist: chroma-hnswlib==0.7.6 ; extra == 'dev'
+Requires-Dist: fastapi>=0.115.9 ; extra == 'dev'
+Requires-Dist: opentelemetry-instrumentation-fastapi>=0.41b0 ; extra == 'dev'
+Provides-Extra: dev
+License-File: LICENSE
+Summary: Chroma.
+Author-email: Jeff Huber , Anton Troynikov
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Bug Tracker, https://github.com/chroma-core/chroma/issues
+Project-URL: Homepage, https://github.com/chroma-core/chroma
+
+
+
+
+
+ Chroma - the open-source data infrastructure for AI.
+
+
+
+
+ 
+ |
+
+ 
+ |
+
+ Docs
+ |
+
+ Homepage
+
+
+
+```bash
+pip install chromadb # python client
+# for javascript, npm install chromadb!
+# for client-server mode, chroma run --path /chroma_db_path
+```
+
+## Chroma Cloud
+
+Our hosted service, Chroma Cloud, powers serverless vector, hybrid, and full-text search. It's extremely fast, cost-effective, scalable and painless. Create a DB and try it out in under 30 seconds with $5 of free credits.
+
+[Get started with Chroma Cloud](https://trychroma.com/signup)
+
+## API
+
+The core API is only 4 functions (run our [💡 Google Colab](https://colab.research.google.com/drive/1QEzFyqnoFxq7LUGyP1vzR4iLt9PpCDXv?usp=sharing)):
+
+```python
+import chromadb
+# setup Chroma in-memory, for easy prototyping. Can add persistence easily!
+client = chromadb.Client()
+
+# Create collection. get_collection, get_or_create_collection, delete_collection also available!
+collection = client.create_collection("all-my-documents")
+
+# Add docs to the collection. Can also update and delete. Row-based API coming soon!
+collection.add(
+ documents=["This is document1", "This is document2"], # we handle tokenization, embedding, and indexing automatically. You can skip that and add your own embeddings as well
+ metadatas=[{"source": "notion"}, {"source": "google-docs"}], # filter on these!
+ ids=["doc1", "doc2"], # unique for each doc
+)
+
+# Query/search 2 most similar results. You can also .get by id
+results = collection.query(
+ query_texts=["This is a query document"],
+ n_results=2,
+ # where={"metadata_field": "is_equal_to_this"}, # optional filter
+ # where_document={"$contains":"search_string"} # optional filter
+)
+```
+
+Learn about all features on our [Docs](https://docs.trychroma.com)
+
+## Get involved
+
+Chroma is a rapidly developing project. We welcome PR contributors and ideas for how to improve the project.
+- [Join the conversation on Discord](https://discord.com/invite/chromadb) - `#contributing` channel
+- [Review the 🛣️ Roadmap and contribute your ideas](https://docs.trychroma.com/docs/overview/oss#roadmap)
+- [Grab an issue and open a PR](https://github.com/chroma-core/chroma/issues) - [`Good first issue tag`](https://github.com/chroma-core/chroma/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22)
+- [Read our contributing guide](https://docs.trychroma.com/docs/overview/oss#contributing)
+
+**Release Cadence**
+We currently release new tagged versions of the `pypi` and `npm` packages on Mondays. Hotfixes go out at any time during the week.
+
+## License
+
+[Apache 2.0](./LICENSE)
+
diff --git a/python/user_packages/Python313/site-packages/chromadb-1.5.9.dist-info/RECORD b/python/user_packages/Python313/site-packages/chromadb-1.5.9.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..98a16ed0c5bc477244be42c3b9c68e8524b71abb
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/chromadb-1.5.9.dist-info/RECORD
@@ -0,0 +1,502 @@
+../Scripts/chroma.exe,sha256=06jYeYTb_8LJaD2nOxu3SIQ-yu91wDhERWIlTlL6kVc,108336
+chromadb-1.5.9.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+chromadb-1.5.9.dist-info/METADATA,sha256=zxsJJYqA6NNAqvtnt03oISfbKL5vI_wt9rLC2GRbbsg,5082
+chromadb-1.5.9.dist-info/RECORD,,
+chromadb-1.5.9.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chromadb-1.5.9.dist-info/WHEEL,sha256=QJT0Dh3DnCQVqMM_9lz6ifPtpM6LPwCwQR8PvQ9wgQc,95
+chromadb-1.5.9.dist-info/entry_points.txt,sha256=vb__WRXGM9B5tQ1Ysrcp3LIgagWxYfyNsd0NS8C_08U,46
+chromadb-1.5.9.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+chromadb-1.5.9.dist-info/sboms/chromadb_rust_bindings.cyclonedx.json,sha256=NyZNe4QmEiGL4TS7ri0Yw10l8PmUkoEn3GhQxRRqTAg,1004151
+chromadb/__init__.py,sha256=J7dWzHi048pEmFYghKzGNPo8PN9-XlUu_hmB__zIpNc,15102
+chromadb/__pycache__/__init__.cpython-313.pyc,,
+chromadb/__pycache__/app.cpython-313.pyc,,
+chromadb/__pycache__/base_types.cpython-313.pyc,,
+chromadb/__pycache__/config.cpython-313.pyc,,
+chromadb/__pycache__/errors.cpython-313.pyc,,
+chromadb/__pycache__/serde.cpython-313.pyc,,
+chromadb/__pycache__/types.cpython-313.pyc,,
+chromadb/api/__init__.py,sha256=-CciQ7AZTdca-1_B92HPLf6ddwoq7jduzozjFMJ9Des,29833
+chromadb/api/__pycache__/__init__.cpython-313.pyc,,
+chromadb/api/__pycache__/async_api.cpython-313.pyc,,
+chromadb/api/__pycache__/async_client.cpython-313.pyc,,
+chromadb/api/__pycache__/async_fastapi.cpython-313.pyc,,
+chromadb/api/__pycache__/base_http_client.cpython-313.pyc,,
+chromadb/api/__pycache__/client.cpython-313.pyc,,
+chromadb/api/__pycache__/collection_configuration.cpython-313.pyc,,
+chromadb/api/__pycache__/configuration.cpython-313.pyc,,
+chromadb/api/__pycache__/fastapi.cpython-313.pyc,,
+chromadb/api/__pycache__/functions.cpython-313.pyc,,
+chromadb/api/__pycache__/rust.cpython-313.pyc,,
+chromadb/api/__pycache__/segment.cpython-313.pyc,,
+chromadb/api/__pycache__/shared_system_client.cpython-313.pyc,,
+chromadb/api/__pycache__/types.cpython-313.pyc,,
+chromadb/api/async_api.py,sha256=p_KcBHC0k2H1V1xKHZvAwCg3fymeMr91B-tS3alucf4,27013
+chromadb/api/async_client.py,sha256=ER4k97w07jjja4qJ_qQlxydIF7o1erLSYFlCQu-HXNE,18759
+chromadb/api/async_fastapi.py,sha256=kJmE1jtiPLjpzRGe79MmSAL7u7hEnCTCh1WQC-Bshd8,29065
+chromadb/api/base_http_client.py,sha256=bBQDYXfHe4p6YeENJDP3kH6k8rLkSHFRS-VXToVpf_s,5411
+chromadb/api/client.py,sha256=onLv0_oblR5ThR-fYhtIH54bhTvcWD4e49puHAVPu0I,24583
+chromadb/api/collection_configuration.py,sha256=Y3eQrhutdZgw956XBAwuQB5crYG0cTIpxiy5mOv4fKY,32905
+chromadb/api/configuration.py,sha256=CxmL6G08ag6gPlsyH_PIicbSN63-4NnqDLGSzOxaK3Q,15583
+chromadb/api/fastapi.py,sha256=J3uo7Ixj_HKQRx01SAAwhlU_CHWkfXJuw3ga8AbYzNI,32000
+chromadb/api/functions.py,sha256=FKsOdKVkLv1RIgrMUoFuU3Py_pPjFXou6vn1Y98y_vc,1023
+chromadb/api/models/AsyncCollection.py,sha256=rNhz3BYWzUHQ90JJUFT6_-oMbIp0X1MeVCCIa35w-XQ,22223
+chromadb/api/models/AttachedFunction.py,sha256=xgnIkP001g4FriXcn1ruI7QwxleD9z2h6NtWbP0UE9s,4717
+chromadb/api/models/Collection.py,sha256=voOJZlA3YTkMq0nul6MK7QyDNi8jtfpapakGHLdOORU,24700
+chromadb/api/models/CollectionCommon.py,sha256=A2_QRPzlk5_SWn8M5wAbwc4kAtDZ8pc24TGM9sPv7Ts,37378
+chromadb/api/models/__pycache__/AsyncCollection.cpython-313.pyc,,
+chromadb/api/models/__pycache__/AttachedFunction.cpython-313.pyc,,
+chromadb/api/models/__pycache__/Collection.cpython-313.pyc,,
+chromadb/api/models/__pycache__/CollectionCommon.cpython-313.pyc,,
+chromadb/api/rust.py,sha256=um2jmugcbn4xsSg9rP3Pz0wDQfmsLCJYnifH292E_H4,23549
+chromadb/api/segment.py,sha256=uO-co_7lrEKWyof3qcmD5NOcYsvqrsPG3NA_B9LJCmw,40009
+chromadb/api/shared_system_client.py,sha256=6oKLR9ACeRDgQv-d1oDb13d_LN0Z8hUg8m0CBmpbVMk,7606
+chromadb/api/types.py,sha256=_WwyiXTzKh_wULEYg6g9Q1O2CxUeYLISbgkNnO3x_fU,113803
+chromadb/app.py,sha256=B2RVywncMIZTajX3r9oOk53U6_8MGQlLb4uGvV2LOrw,175
+chromadb/auth/__init__.py,sha256=gI2ExiyIYVmjZ7uIDoOglqEa5vorcKkann-qPVkYCuw,8388
+chromadb/auth/__pycache__/__init__.cpython-313.pyc,,
+chromadb/auth/basic_authn/__init__.py,sha256=Ab6QLLV9fvFGqmmIQaKI0XtABMjJBm-DyJElpbYFYZ0,5238
+chromadb/auth/basic_authn/__pycache__/__init__.cpython-313.pyc,,
+chromadb/auth/simple_rbac_authz/__init__.py,sha256=5yDgrS8V1PCkm4Yhy0hyk-vR4fLamaMYWmJ9MnCAJU0,2718
+chromadb/auth/simple_rbac_authz/__pycache__/__init__.cpython-313.pyc,,
+chromadb/auth/token_authn/__init__.py,sha256=M5l7_dcibBXa-p2-EvMul7iSBr6oMAtle3MtK3IpAjM,8563
+chromadb/auth/token_authn/__pycache__/__init__.cpython-313.pyc,,
+chromadb/auth/utils/__init__.py,sha256=3Zlfm8Gi2x_iu0c3uWDDBZ10_rtGkTiQL6aR2qQZJh8,3813
+chromadb/auth/utils/__pycache__/__init__.cpython-313.pyc,,
+chromadb/base_types.py,sha256=cAH6KUKZpMBUxv_nc0YsdapS559hfQXeD3gd8NbQ-Pc,6149
+chromadb/chromadb_rust_bindings.pyi,sha256=DxHqL0eQYZyJ_JYsIfuPuc9GBLMhYAHO6pvh2De5nnQ,6149
+chromadb/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chromadb/cli/__pycache__/__init__.cpython-313.pyc,,
+chromadb/cli/__pycache__/cli.cpython-313.pyc,,
+chromadb/cli/__pycache__/utils.cpython-313.pyc,,
+chromadb/cli/cli.py,sha256=BqXgIGWNfkiTVwwQucJ-_4nZCSbBtqAbM3ANI0glkTI,1549
+chromadb/cli/utils.py,sha256=AzxNgX_GtgXU3DvZVwFQ8nuh0_usd4v6_ttOB4HeZLQ,1287
+chromadb/config.py,sha256=07Xk-0IYrpXkirTRJzWZhAzf2I4SGRUxnx2lf8zrpZ4,19001
+chromadb/db/__init__.py,sha256=tANHwrFzaK31HW4DeeHbt-enZtPMVoKvGirWIVxADCE,3162
+chromadb/db/__pycache__/__init__.cpython-313.pyc,,
+chromadb/db/__pycache__/base.cpython-313.pyc,,
+chromadb/db/__pycache__/migrations.cpython-313.pyc,,
+chromadb/db/__pycache__/system.cpython-313.pyc,,
+chromadb/db/base.py,sha256=NsfSrNfo00nCljF9OLvYbbZFSRKNaJJvosPKOtp8WMQ,5945
+chromadb/db/impl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chromadb/db/impl/__pycache__/__init__.cpython-313.pyc,,
+chromadb/db/impl/__pycache__/sqlite.cpython-313.pyc,,
+chromadb/db/impl/__pycache__/sqlite_pool.cpython-313.pyc,,
+chromadb/db/impl/grpc/__pycache__/client.cpython-313.pyc,,
+chromadb/db/impl/grpc/__pycache__/server.cpython-313.pyc,,
+chromadb/db/impl/grpc/client.py,sha256=aZiOPMR5ChXdjPsodf6b2oKPwtY0hY0VN8q2dJVeNFA,20943
+chromadb/db/impl/grpc/server.py,sha256=2erX-v961KJ2nloSYh3pznKKPFSnXtZ6n58ZfpBk1a4,21226
+chromadb/db/impl/sqlite.py,sha256=0a5dvius60f24qnCl0IFlPv81eK0ETsjfXzDySooJRw,9703
+chromadb/db/impl/sqlite_pool.py,sha256=jGbFeQL99eQ2tyf-Eh9YuZayzrLScZTEsRix532mQ_o,5535
+chromadb/db/migrations.py,sha256=BepOJSL8A4djpmeR11tTKidOtbn-x2dSFz2QbdZdTNM,9906
+chromadb/db/mixins/__pycache__/embeddings_queue.cpython-313.pyc,,
+chromadb/db/mixins/__pycache__/sysdb.cpython-313.pyc,,
+chromadb/db/mixins/embeddings_queue.py,sha256=sIwl6PJIZJckTbmZkHSIlXAYGNB3TdvfEJ_LHtqPKR4,19832
+chromadb/db/mixins/sysdb.py,sha256=bH_FZke_BgdWCr__X7a53Pr6oGg8rDCJtaaxPN_JzZY,37941
+chromadb/db/system.py,sha256=VVR_xQR_hZwHdgTMfI0btKAGk7fQGNagofktUJSpUaE,6396
+chromadb/errors.py,sha256=YMzdOgNqvoM7659MG970c9kp3dyW76-vH3hANGhbN-M,4212
+chromadb/execution/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chromadb/execution/__pycache__/__init__.cpython-313.pyc,,
+chromadb/execution/executor/__pycache__/abstract.cpython-313.pyc,,
+chromadb/execution/executor/__pycache__/distributed.cpython-313.pyc,,
+chromadb/execution/executor/__pycache__/local.cpython-313.pyc,,
+chromadb/execution/executor/abstract.py,sha256=dFzh7ji9EhqIc2iI3siEyYipXhRVEY_6q4KQ3ckwkE4,489
+chromadb/execution/executor/distributed.py,sha256=AwtJGB9dP-bpc6JXN8CzAL66MuSwQwk_apzG6ggQz-k,9277
+chromadb/execution/executor/local.py,sha256=PEpZNYkyyxKsh6PkUVwEF_r0zXZ6wxPTwnQHob9DE14,7725
+chromadb/execution/expression/__init__.py,sha256=_nFg8oS9GUy463WT2x_Cl6kanZCcXfu-GpPyiku-pFY,1459
+chromadb/execution/expression/__pycache__/__init__.cpython-313.pyc,,
+chromadb/execution/expression/__pycache__/operator.cpython-313.pyc,,
+chromadb/execution/expression/__pycache__/plan.cpython-313.pyc,,
+chromadb/execution/expression/operator.py,sha256=Mft7GnURo71YEjGQZE6pnK9yLhyZyUvDCGpJ94XAeqQ,53651
+chromadb/execution/expression/plan.py,sha256=M-zundl9vwAMBOuUTn50SYVse7A-v4E3IfcnCDx0Y2s,9895
+chromadb/experimental/density_relevance.ipynb,sha256=ks8SSD1jH8ChjfS9fmBeMKXjpNHnF8heF9juWRuDm8o,369242
+chromadb/ingest/__init__.py,sha256=aRKfCkjWqzkCep9XpoIRjRxhu7n8O-faEo2WmcfEFys,4420
+chromadb/ingest/__pycache__/__init__.cpython-313.pyc,,
+chromadb/ingest/impl/__pycache__/utils.cpython-313.pyc,,
+chromadb/ingest/impl/utils.py,sha256=NgsUC0RPrd5LQMk1BhVRXDE_xiEQ6Z8SjAdrbjzlkUw,1882
+chromadb/log_config.yml,sha256=y6lDM7gCNcSmtuAL6nIkaTNZvdwsIz6YLvoep4nkRuA,958
+chromadb/logservice/__pycache__/logservice.cpython-313.pyc,,
+chromadb/logservice/logservice.py,sha256=MZW45v6mg7bcSOnjMPHHIsJJVNjATm5LxMNw-5ShI50,6051
+chromadb/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chromadb/migrations/__pycache__/__init__.cpython-313.pyc,,
+chromadb/migrations/embeddings_queue/00001-embeddings.sqlite.sql,sha256=yXegLSX1rymqnDQNfhhWUnzf_P724alduquFBVzGScA,271
+chromadb/migrations/embeddings_queue/00002-embeddings-queue-config.sqlite.sql,sha256=4ps1zRXbaD2yqgfcT0wFo99Afi1pK1MPkAZpdczdUSQ,99
+chromadb/migrations/metadb/00001-embedding-metadata.sqlite.sql,sha256=DSFWXw0aQ-5O-er1DwjG1uWS1gFK1U3-IrMdzy2qMCI,624
+chromadb/migrations/metadb/00002-embedding-metadata.sqlite.sql,sha256=Dkd8KxRG8R2pMJKNjFmL4tJE2UeVcmIv0sb_ANORVgY,339
+chromadb/migrations/metadb/00003-full-text-tokenize.sqlite.sql,sha256=90gDZf9YDGALlnbyurEn-T8MsHDkwNBgnxRwDZVc_Es,239
+chromadb/migrations/metadb/00004-metadata-indices.sqlite.sql,sha256=nVKGTYqUNqLKxo0x3GqtBIhnbAaeo6E5kYCrAW8vscY,390
+chromadb/migrations/metadb/00005-max-seq-id-int.sqlite.sql,sha256=7IEzqfPPAaLS2CRfbXD65McVqFwQhWBQDnHQEGHT6x8,1476
+chromadb/migrations/sysdb/00001-collections.sqlite.sql,sha256=ItDox_ib7k9dngqibUNSPVRtHltrznIrVaoXAdl5AYw,370
+chromadb/migrations/sysdb/00002-segments.sqlite.sql,sha256=MiE1dmc3SUJJiyULPHLWQdfA5bzO-j27jMDUr-NzYas,401
+chromadb/migrations/sysdb/00003-collection-dimension.sqlite.sql,sha256=oQXqpTbKO9mCXotFpREEoK-pK2yRKRp0XuMKCkLOWN8,55
+chromadb/migrations/sysdb/00004-tenants-databases.sqlite.sql,sha256=-nlyv0U6_rXdbPkkuGV4ZwMEa3wWd6nC0BXdw77k3hA,1257
+chromadb/migrations/sysdb/00005-remove-topic.sqlite.sql,sha256=FspWWbQu0rJ8WV9Cc2DozVTto0LxiHyXpDU7QChFXhE,156
+chromadb/migrations/sysdb/00006-collection-segment-metadata.sqlite.sql,sha256=AfQ9XlYn8QbxEXr0EMYOHZqfHiG09f65pVFJckHQ9Rw,402
+chromadb/migrations/sysdb/00007-collection-config.sqlite.sql,sha256=Ri2DxB8iIcnxxlNtXM2sHZel3abL48_pvuSNh30MIos,108
+chromadb/migrations/sysdb/00008-maintenance-log.sqlite.sql,sha256=mFVVaCvrkO39V8qKWxd2MT7QCiycoZgWqZgtvQ1jjzA,255
+chromadb/migrations/sysdb/00009-segment-collection-not-null.sqlite.sql,sha256=isC6vg28aZDppxLYERNIBcluyIiwjKsxJx-cAGxH34s,338
+chromadb/proto/.gitignore,sha256=Ss9RnWXKRkXGGRKOPRkyd4EDhgv3ZfsseJ2faiTiBUg,26
+chromadb/proto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chromadb/proto/__pycache__/__init__.cpython-313.pyc,,
+chromadb/proto/__pycache__/convert.cpython-313.pyc,,
+chromadb/proto/__pycache__/utils.cpython-313.pyc,,
+chromadb/proto/convert.py,sha256=ALODRF017LJmWgpfLeFbxrUJeZoFSHOTQd8VMHJ0VXw,27307
+chromadb/proto/utils.py,sha256=vr37wPgIbsde1RR11fvoNAzqVZVLI0_jmkVrDPcugSY,2638
+chromadb/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chromadb/quota/__init__.py,sha256=ZdUCiMPGTA83l1omghw043cZnM3b01jiqe_8sG8Aww8,1888
+chromadb/quota/__pycache__/__init__.cpython-313.pyc,,
+chromadb/quota/simple_quota_enforcer/__init__.py,sha256=chUn4f5kYjXCdI-qG1wawBKuLMGmwzlzWENLLX6EeCM,1549
+chromadb/quota/simple_quota_enforcer/__pycache__/__init__.cpython-313.pyc,,
+chromadb/rate_limit/__init__.py,sha256=YhPyWqXqvpFpHnTqeA_2PuBRNfRdpkYZPdI35n3r9gA,925
+chromadb/rate_limit/__pycache__/__init__.cpython-313.pyc,,
+chromadb/rate_limit/simple_rate_limit/__init__.py,sha256=S6MJoR9mrCVcCUKSAfBNWisk9nmCKPck8jC6lEr_p80,1219
+chromadb/rate_limit/simple_rate_limit/__pycache__/__init__.cpython-313.pyc,,
+chromadb/segment/__init__.py,sha256=eODfbn9NFgwsnzVlyMtgbV4dtEVJuF2esotIrWHjNLg,4145
+chromadb/segment/__pycache__/__init__.cpython-313.pyc,,
+chromadb/segment/distributed/__init__.py,sha256=cWpsMpo4uQnPMVVflML1C3JE4jSBQqWZ6ZwhfUgu_kM,2783
+chromadb/segment/distributed/__pycache__/__init__.cpython-313.pyc,,
+chromadb/segment/impl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chromadb/segment/impl/__pycache__/__init__.cpython-313.pyc,,
+chromadb/segment/impl/distributed/__pycache__/segment_directory.cpython-313.pyc,,
+chromadb/segment/impl/distributed/segment_directory.py,sha256=eC_8i235YBDMbKNLBVdzPv7wMUFBQXYfELAzDHI6nXs,13730
+chromadb/segment/impl/manager/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chromadb/segment/impl/manager/__pycache__/__init__.cpython-313.pyc,,
+chromadb/segment/impl/manager/__pycache__/distributed.cpython-313.pyc,,
+chromadb/segment/impl/manager/__pycache__/local.cpython-313.pyc,,
+chromadb/segment/impl/manager/cache/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chromadb/segment/impl/manager/cache/__pycache__/__init__.cpython-313.pyc,,
+chromadb/segment/impl/manager/cache/__pycache__/cache.cpython-313.pyc,,
+chromadb/segment/impl/manager/cache/cache.py,sha256=f6TjCvWkke2NH6LK9q2HvhAFrOmhMbPAhIRwqRscnRw,3554
+chromadb/segment/impl/manager/distributed.py,sha256=AYEgGf8KlXptQ2zJ-RHG7r6-7w1eEeuH8VwLsY7Enes,3083
+chromadb/segment/impl/manager/local.py,sha256=psVULgN6hfUv_jQPAp2c2z187OGqWNwhmaCtV6PuW-o,10862
+chromadb/segment/impl/metadata/__pycache__/sqlite.cpython-313.pyc,,
+chromadb/segment/impl/metadata/sqlite.py,sha256=QP4RheEfXTNy9kUCA9jK7byCAinNzs5MyRfRefLamrs,26509
+chromadb/segment/impl/vector/__pycache__/batch.cpython-313.pyc,,
+chromadb/segment/impl/vector/__pycache__/brute_force_index.cpython-313.pyc,,
+chromadb/segment/impl/vector/__pycache__/hnsw_params.cpython-313.pyc,,
+chromadb/segment/impl/vector/__pycache__/local_hnsw.cpython-313.pyc,,
+chromadb/segment/impl/vector/__pycache__/local_persistent_hnsw.cpython-313.pyc,,
+chromadb/segment/impl/vector/batch.py,sha256=0ucpl0L4M1CYk0ihl7moIRRHr-2i4dQ3QrTiFGN7veA,4319
+chromadb/segment/impl/vector/brute_force_index.py,sha256=g03ZD1ZaVfUrjFBlOP_XoDYMf5YyzJ6OBuG6CVPpsgY,5571
+chromadb/segment/impl/vector/hnsw_params.py,sha256=oJcHMNkB_Pwjp9l3ayXzpYobAZikBZVVn8qoQQbGhi8,3250
+chromadb/segment/impl/vector/local_hnsw.py,sha256=-a0U4CVdjl10jHBtvl1PmhPEzNJpSUGkuLkUBFJTRto,12378
+chromadb/segment/impl/vector/local_persistent_hnsw.py,sha256=yMFtM6f8AKjyMp9lMdY74Ur_FhLH80OtIZVtoZngtzk,22692
+chromadb/serde.py,sha256=otSk0Xh9h1gIzegXUXne_ke2w9cXNB4o4dxAq0fAJbU,1552
+chromadb/server/__init__.py,sha256=_VbOGchxMmMlSC1Z8SzcL6J7w6uOelqV-X8vR4UPKv4,181
+chromadb/server/__pycache__/__init__.cpython-313.pyc,,
+chromadb/server/fastapi/__init__.py,sha256=5jOtAeb87kCbp4PLfR2XLb5hDTj9TYq12O-25Cmz48U,78297
+chromadb/server/fastapi/__pycache__/__init__.cpython-313.pyc,,
+chromadb/server/fastapi/__pycache__/types.cpython-313.pyc,,
+chromadb/server/fastapi/types.py,sha256=E-8zkV4p6GhIW91y8eALy66CExgETepUvHJ9Cq1O9BQ,2645
+chromadb/telemetry/README.md,sha256=O9nVNPAMEb2tXTUBsHMZZ9dNkLVzzqu2x5a9Mz-jr04,597
+chromadb/telemetry/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chromadb/telemetry/__pycache__/__init__.cpython-313.pyc,,
+chromadb/telemetry/opentelemetry/__init__.py,sha256=ZHb1lsOeggtdriz_Gb4c7BW_C2L8fUR7V66WIqcoA_c,6208
+chromadb/telemetry/opentelemetry/__pycache__/__init__.cpython-313.pyc,,
+chromadb/telemetry/opentelemetry/__pycache__/fastapi.cpython-313.pyc,,
+chromadb/telemetry/opentelemetry/__pycache__/grpc.cpython-313.pyc,,
+chromadb/telemetry/opentelemetry/fastapi.py,sha256=8LFsxJcauSzR3wOx1cFDlNhveI-6RNKw2upblvnVWVw,415
+chromadb/telemetry/opentelemetry/grpc.py,sha256=BDlkM3DKo3rbD0Nwpawyur2Dv8wtvQdZMju2eCZOt4o,3826
+chromadb/telemetry/product/__init__.py,sha256=ZGDTlOfVL-GbFMBsu0ea2D-ZzWJK7rSkJI9ShADfsHA,3033
+chromadb/telemetry/product/__pycache__/__init__.cpython-313.pyc,,
+chromadb/telemetry/product/__pycache__/events.cpython-313.pyc,,
+chromadb/telemetry/product/__pycache__/posthog.cpython-313.pyc,,
+chromadb/telemetry/product/events.py,sha256=bajKYbxrcTg5VHmpJqR_6Nkw1_koN9CSzlAP8Dix_sM,8921
+chromadb/telemetry/product/posthog.py,sha256=4lPbrnVxyvM-leFVZOJpcJXroFWnEETw_02tM8wRcyE,269
+chromadb/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chromadb/test/__pycache__/__init__.cpython-313.pyc,,
+chromadb/test/__pycache__/conftest.cpython-313.pyc,,
+chromadb/test/__pycache__/test_api.cpython-313.pyc,,
+chromadb/test/__pycache__/test_chroma.cpython-313.pyc,,
+chromadb/test/__pycache__/test_cli.cpython-313.pyc,,
+chromadb/test/__pycache__/test_client.cpython-313.pyc,,
+chromadb/test/__pycache__/test_config.cpython-313.pyc,,
+chromadb/test/__pycache__/test_multithreaded.cpython-313.pyc,,
+chromadb/test/api/__pycache__/test_collection.cpython-313.pyc,,
+chromadb/test/api/__pycache__/test_count_api.cpython-313.pyc,,
+chromadb/test/api/__pycache__/test_delete_database.cpython-313.pyc,,
+chromadb/test/api/__pycache__/test_fork_count_api.cpython-313.pyc,,
+chromadb/test/api/__pycache__/test_get_database.cpython-313.pyc,,
+chromadb/test/api/__pycache__/test_indexing_status.cpython-313.pyc,,
+chromadb/test/api/__pycache__/test_invalid_update.cpython-313.pyc,,
+chromadb/test/api/__pycache__/test_limit_offset.cpython-313.pyc,,
+chromadb/test/api/__pycache__/test_list_databases.cpython-313.pyc,,
+chromadb/test/api/__pycache__/test_numpy_list_inputs.cpython-313.pyc,,
+chromadb/test/api/__pycache__/test_schema.cpython-313.pyc,,
+chromadb/test/api/__pycache__/test_schema_e2e.cpython-313.pyc,,
+chromadb/test/api/__pycache__/test_search_api.cpython-313.pyc,,
+chromadb/test/api/__pycache__/test_shared_system_client.cpython-313.pyc,,
+chromadb/test/api/__pycache__/test_types.cpython-313.pyc,,
+chromadb/test/api/test_collection.py,sha256=59HByUNp1G5foZrNMnuFdWvbnKis-hbPL4BJVitXVy8,2424
+chromadb/test/api/test_count_api.py,sha256=AJhnx-s_d5jUF6eun8psOAfPWijdeUH4gKXMrAO2sgE,3616
+chromadb/test/api/test_delete_database.py,sha256=3Xt7krOab0jS_8Oj9ZcKfAuENMMBs3k4e7XhMkh0n1k,2753
+chromadb/test/api/test_fork_count_api.py,sha256=THUTV0-jwAiTMcu8wbfzq7moS4c5_oT5YVdPZ553P6s,3874
+chromadb/test/api/test_get_database.py,sha256=t0anbly2EDezRlm3sl2cwLQDW-cJMlkm0hGKr8a_XnI,298
+chromadb/test/api/test_indexing_status.py,sha256=vAzd5xx56eNEv52nURxjD2f91WURELjQMTZihYB1mfo,9688
+chromadb/test/api/test_invalid_update.py,sha256=zGwphQtPV-Rz90RbXdaLCg_DJs1MnVy-K6R_uwZGfp4,625
+chromadb/test/api/test_limit_offset.py,sha256=Sw0-zsKgUtWK7b0kkUHpoJIQmtjbmJguIke3xHpBvP4,2091
+chromadb/test/api/test_list_databases.py,sha256=vDDVx73MAB9aQIzVCasmIUoeoKDNQ2eR1vhkMrBYZe8,3504
+chromadb/test/api/test_numpy_list_inputs.py,sha256=ssCiOTkO0XaMlMEMjvH9dUGghdTSLCuqJbh3XHlYjlU,2147
+chromadb/test/api/test_schema.py,sha256=ss0DosUyHkqRBbnJ5ZAm0_dC7u5s7zq6rTgxRU0XCgY,146989
+chromadb/test/api/test_schema_e2e.py,sha256=EAcHXooW7dM94H8WAGbMVOJABYgg0XxGu5EzYiFoaOY,106999
+chromadb/test/api/test_search_api.py,sha256=LhogcVVtSc7aMb_yoA_mCVWkjliwhLkxDBWWnKqQTVE,4602
+chromadb/test/api/test_shared_system_client.py,sha256=OsHM0ypI8YnpLFySxEOWPvIAwLkIu2CwtLceQh70vnw,6106
+chromadb/test/api/test_types.py,sha256=P27zFtLw3lovxf7C7PufH7Q-OAjx5PahU7HDRlhUIqg,3324
+chromadb/test/auth/__pycache__/test_auth_utils.cpython-313.pyc,,
+chromadb/test/auth/__pycache__/test_rbac_authz.cpython-313.pyc,,
+chromadb/test/auth/test_auth_utils.py,sha256=u_QnOzVkOKbgUJggE-L2xAfqWM7ENfWXeDsNOIR6-iM,3126
+chromadb/test/auth/test_rbac_authz.py,sha256=KXHhjyzZ4K_H3oGm0sol7rDc4bNlLBmFudejTuuEO7c,629
+chromadb/test/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chromadb/test/client/__pycache__/__init__.cpython-313.pyc,,
+chromadb/test/client/__pycache__/create_http_client_with_basic_auth.cpython-313.pyc,,
+chromadb/test/client/__pycache__/test_cloud_client.cpython-313.pyc,,
+chromadb/test/client/__pycache__/test_create_http_client.cpython-313.pyc,,
+chromadb/test/client/__pycache__/test_database_tenant.cpython-313.pyc,,
+chromadb/test/client/__pycache__/test_database_tenant_auth.cpython-313.pyc,,
+chromadb/test/client/__pycache__/test_multiple_clients_concurrency.cpython-313.pyc,,
+chromadb/test/client/create_http_client_with_basic_auth.py,sha256=Zq6Yjs0EjgpcmE9s6dB0bfvPHFqdxwzjjJrGaKimrog,814
+chromadb/test/client/test_cloud_client.py,sha256=VwTGE5nQQN5absKS8bSFZ4pRjJkwt4w-DX1PZXOlw7M,12801
+chromadb/test/client/test_create_http_client.py,sha256=9pbHdJ_rUj6U3609SNGfrcDGi4Hpb9SG5l1DlmgJUaM,572
+chromadb/test/client/test_database_tenant.py,sha256=UKBAp-_jLYz7TsXLDF7oST6mtORuvcmNTdr2zgFxfxc,7291
+chromadb/test/client/test_database_tenant_auth.py,sha256=tnmvnlDKVIaZM10vWCMpj3qbafDeJK_xbUDT7qovC8w,1412
+chromadb/test/client/test_multiple_clients_concurrency.py,sha256=hx3ISUBCgztRVieciI9IS_0nkNXpXBXMwh_g1dHih94,2055
+chromadb/test/configurations/__pycache__/test_collection_configuration.cpython-313.pyc,,
+chromadb/test/configurations/__pycache__/test_configurations.cpython-313.pyc,,
+chromadb/test/configurations/test_collection_configuration.py,sha256=o6WGCYrMjv6OEr-rQf-lRtsnz6g6vdyvsSn6CV4fx5o,62780
+chromadb/test/configurations/test_configurations.py,sha256=TzyTzPpYzigrVcBYlfGrmgE60W3uLOJi-WH-o_POt8M,3790
+chromadb/test/conftest.py,sha256=4qwwjRXjnraSUgZ9Zdat2B6Ctis74ohqlnm2HhR7bd0,43713
+chromadb/test/data_loader/__pycache__/test_data_loader.cpython-313.pyc,,
+chromadb/test/data_loader/test_data_loader.py,sha256=80m62vUH9sSLFEMrq9ibrAwW7Vih83ycwEoUrsSIOHY,3830
+chromadb/test/db/__pycache__/test_log_purge.cpython-313.pyc,,
+chromadb/test/db/test_log_purge.py,sha256=RGPFjnYrIgeTTpkkiyAMfgPP-74WvJ7hr7gjs3cjc3c,1823
+chromadb/test/distributed/README.md,sha256=fwQFXTGy-sIvTmmieTzQJA49ohgdirx9P9AoznwFjxc,236
+chromadb/test/distributed/__pycache__/test_log_backpressure.cpython-313.pyc,,
+chromadb/test/distributed/__pycache__/test_repair_collection_log_offset.cpython-313.pyc,,
+chromadb/test/distributed/__pycache__/test_reroute.cpython-313.pyc,,
+chromadb/test/distributed/__pycache__/test_sanity.cpython-313.pyc,,
+chromadb/test/distributed/__pycache__/test_statistics_wrapper.cpython-313.pyc,,
+chromadb/test/distributed/__pycache__/test_task_api.cpython-313.pyc,,
+chromadb/test/distributed/test_log_backpressure.py,sha256=eipGjgylUKI_vcdqyFs3lYHJaVhmIFYex-bbC3fEV08,1757
+chromadb/test/distributed/test_repair_collection_log_offset.py,sha256=DYw9ldVjN_shD6SMk5Lg5_EAP4PmP3q2zkbrk7zfHwI,3761
+chromadb/test/distributed/test_reroute.py,sha256=vRmckCusEopqn-aOvvqoqOg26i1hlPAo7UChdSf3Rj8,2516
+chromadb/test/distributed/test_sanity.py,sha256=BIUuuA8xz-R0n6XgIkjbC-1UAahLk8muevH08dUuh-s,3048
+chromadb/test/distributed/test_statistics_wrapper.py,sha256=vlPcFFCfrZxOFKVnosB2YdIoyKhsUU_ChaRP9YNQ0P8,18195
+chromadb/test/distributed/test_task_api.py,sha256=UCVg6he1Nlc5cAgfwqgIFK50Co6DihDkqAVBYhUFg-g,20901
+chromadb/test/ef/__pycache__/test_chroma_bm25_embedding_function.cpython-313.pyc,,
+chromadb/test/ef/__pycache__/test_custom_ef.cpython-313.pyc,,
+chromadb/test/ef/__pycache__/test_default_ef.cpython-313.pyc,,
+chromadb/test/ef/__pycache__/test_ef.cpython-313.pyc,,
+chromadb/test/ef/__pycache__/test_morph_ef.cpython-313.pyc,,
+chromadb/test/ef/__pycache__/test_multimodal_ef.cpython-313.pyc,,
+chromadb/test/ef/__pycache__/test_ollama_ef.cpython-313.pyc,,
+chromadb/test/ef/__pycache__/test_onnx_mini_lm_l6_v2.cpython-313.pyc,,
+chromadb/test/ef/__pycache__/test_openai_ef.cpython-313.pyc,,
+chromadb/test/ef/__pycache__/test_voyageai_ef.cpython-313.pyc,,
+chromadb/test/ef/test_chroma_bm25_embedding_function.py,sha256=yQ13CZp55myppEJIACHw4C4XKo4Cx-Hc_rmYE2dbVaQ,7770
+chromadb/test/ef/test_custom_ef.py,sha256=FrEoV6jM0ayEARH5noaSsZVdjs2W7B4R4R0rBi51Wkk,3398
+chromadb/test/ef/test_default_ef.py,sha256=-b-WygqhPgGj0HXzlLoovpvcX-HFGgPo1LSit_TbjLo,2750
+chromadb/test/ef/test_ef.py,sha256=LTZ7aQG_-xUs35R2zjFNSfKL1WXFaqEyfmsrM3Da058,4179
+chromadb/test/ef/test_morph_ef.py,sha256=WvX5o19Y9tHB9aRMxt2gDpdMeiPHkb2GlC7AKN01a8o,4291
+chromadb/test/ef/test_multimodal_ef.py,sha256=KdS6bJWe8-8yd9XUrSiktBab_qa2OYsKzHUxjXcoDYg,6343
+chromadb/test/ef/test_ollama_ef.py,sha256=UVG8Zxxy-q1LSNJiLp3KRqy3SH1t2glZDG6DmIm4kuA,1885
+chromadb/test/ef/test_onnx_mini_lm_l6_v2.py,sha256=w3waXSCQ7_G2bKV9ckwXzYrqJdZAlQYITmdhJyGHMIc,7746
+chromadb/test/ef/test_openai_ef.py,sha256=1OkvA_srh9I9jAmXg64v0zx64gWbvodgWDnHt6qU9bU,1284
+chromadb/test/ef/test_voyageai_ef.py,sha256=QgxIGza1M9vo-rhvY6KAt_DvRSa0lLL6IgHLqhXwz4U,622
+chromadb/test/openssl.cnf,sha256=lcaXW8qo1ql7AsI2us5KGyT_49glqD3OCLFYye0YPz4,201
+chromadb/test/property/__pycache__/invariants.cpython-313.pyc,,
+chromadb/test/property/__pycache__/strategies.cpython-313.pyc,,
+chromadb/test/property/__pycache__/test_add.cpython-313.pyc,,
+chromadb/test/property/__pycache__/test_add_gc.cpython-313.pyc,,
+chromadb/test/property/__pycache__/test_add_mcmr.cpython-313.pyc,,
+chromadb/test/property/__pycache__/test_base64_conversion.cpython-313.pyc,,
+chromadb/test/property/__pycache__/test_client_url.cpython-313.pyc,,
+chromadb/test/property/__pycache__/test_collections.cpython-313.pyc,,
+chromadb/test/property/__pycache__/test_collections_with_database_tenant.cpython-313.pyc,,
+chromadb/test/property/__pycache__/test_collections_with_database_tenant_overwrite.cpython-313.pyc,,
+chromadb/test/property/__pycache__/test_cross_version_persist.cpython-313.pyc,,
+chromadb/test/property/__pycache__/test_embeddings.cpython-313.pyc,,
+chromadb/test/property/__pycache__/test_filtering.cpython-313.pyc,,
+chromadb/test/property/__pycache__/test_fork.cpython-313.pyc,,
+chromadb/test/property/__pycache__/test_persist.cpython-313.pyc,,
+chromadb/test/property/__pycache__/test_restart_persist.cpython-313.pyc,,
+chromadb/test/property/__pycache__/test_schema.cpython-313.pyc,,
+chromadb/test/property/invariants.py,sha256=jNnuktBgfdNLgtCGHqK1ddcUmHk9L7Xjymz1V1dyKG8,24862
+chromadb/test/property/strategies.py,sha256=TBpI_uII-DbDf_Pvw-IFpQaBCmOvwqlI_1RBTh61aHg,40882
+chromadb/test/property/test_add.py,sha256=D9k3vbA3y-z13p9DMjSa_J-_5dcSpd1sDHn03GID7Xk,19499
+chromadb/test/property/test_add_gc.py,sha256=zX5M_kbDLaWQJyBoTxy__8tq35DQ9FeCWcTKEjxiZS0,16482
+chromadb/test/property/test_add_mcmr.py,sha256=DePohAIjPWzHmuwDW3jKTnqiK62Q-I4rpZGBIIbdoRQ,12677
+chromadb/test/property/test_base64_conversion.py,sha256=u5xAc-8-hA46NHRzyK2cXek5WunFFBQ5TM5Tg5KnMxk,4106
+chromadb/test/property/test_client_url.py,sha256=X51GnpgX9nZ1yK1-Q_Tpccg02KdtWJr-EIx26Gb59ug,4015
+chromadb/test/property/test_collections.py,sha256=hElSxAJoMkNRxhn6UQr2E43NoLC9wFkwlFse9uJK8bY,12739
+chromadb/test/property/test_collections_with_database_tenant.py,sha256=oCHEBkQZeykVwH-B08ezBNPytvLmVe5a67ensGQQ37U,6928
+chromadb/test/property/test_collections_with_database_tenant_overwrite.py,sha256=qPudAAempfQxBF7GOUO6joKtNReWaAB4GdA5x-RfQDY,9589
+chromadb/test/property/test_cross_version_persist.py,sha256=aLuARjmWSh4JuFaZDYg4DU9nNuefxbK34nC7tWU-gfc,14107
+chromadb/test/property/test_embeddings.py,sha256=_88U5fctMRwl83vywhfHdjtbVzLzq6B-cnO2oUUoe1I,54948
+chromadb/test/property/test_filtering.py,sha256=V7ZO_5c1MMk3e3ZcXpPKl1Eax_H1SWdSXA0rBtIaP7c,29190
+chromadb/test/property/test_fork.py,sha256=NVcT9y2336DaH5go4lxo05VWDVKDlm8A-Zp7NdDRPeM,8038
+chromadb/test/property/test_persist.py,sha256=lFQUtdFwXmq4gQjoyKSv5-ZeaEHDD3w18fAig4OuM8Q,24298
+chromadb/test/property/test_restart_persist.py,sha256=aM6z0EL6UB2fm3zHPMwTxeEY9UsMoXicfI_Wy3SltFg,3433
+chromadb/test/property/test_schema.py,sha256=2t7IL4ap4uHN4f5t108X4CTdr8OYYZurGOT9Ux0u2ks,34116
+chromadb/test/segment/distributed/__pycache__/test_memberlist_provider.cpython-313.pyc,,
+chromadb/test/segment/distributed/__pycache__/test_rendezvous_hash.cpython-313.pyc,,
+chromadb/test/segment/distributed/test_memberlist_provider.py,sha256=kJm9gA7vCn5dEBXDCupD9cYM6txlOax7wSKrVu9mc5A,3959
+chromadb/test/segment/distributed/test_rendezvous_hash.py,sha256=DW9HjvWUBdFoYx4fFtJiqRr-EbyZJRZhX5MxwVAYNf4,2317
+chromadb/test/stress/__pycache__/test_many_collections.cpython-313.pyc,,
+chromadb/test/stress/test_many_collections.py,sha256=upJvCde0eMp87QRG4VojyyYabpK1Hvxbwni85boT_Ow,1302
+chromadb/test/test_api.py,sha256=zjXhKpB7JAjlywiP2-6qiVqxJROxkopw5QaHxi4I7Jo,138480
+chromadb/test/test_chroma.py,sha256=D7n4cQzwBdutGKzy9ryoAH7DqM3bz4UQLdrI9O2zOAc,4445
+chromadb/test/test_cli.py,sha256=WRXYdQVROsdEd_c_mL605LCWpaVIbJTS8Fki4so-TF8,5206
+chromadb/test/test_client.py,sha256=Jge16Qq2t4Jr3Ea5C3UZVo-1ND51-nML6h2Y5q0U74c,9675
+chromadb/test/test_config.py,sha256=hGBQ4_RHi1hKyvKUZaSzUQ46IaXVYQMY_YVv_7n8c7s,5816
+chromadb/test/test_multithreaded.py,sha256=l4tAqwtZkFnprXzyzcTLN_fSxWow93PdmDA2gB364TA,8771
+chromadb/test/utils/__pycache__/cross_version.cpython-313.pyc,,
+chromadb/test/utils/__pycache__/distance_functions.cpython-313.pyc,,
+chromadb/test/utils/__pycache__/test_embedding_function_schemas.cpython-313.pyc,,
+chromadb/test/utils/__pycache__/test_result_df_transform.cpython-313.pyc,,
+chromadb/test/utils/__pycache__/test_wait_for_version_increase.cpython-313.pyc,,
+chromadb/test/utils/__pycache__/wait_for_version_increase.cpython-313.pyc,,
+chromadb/test/utils/cross_version.py,sha256=VehiPSdvcpoVoEuwC-u6LaGmdFp1l_pOqhE8qsksgwY,2443
+chromadb/test/utils/distance_functions.py,sha256=tFCiDMkFLR0cuMKBa-RxgHuKt3efoi0RrM76DSrwo1g,191
+chromadb/test/utils/test_embedding_function_schemas.py,sha256=_UfRDOwd1vHVjYByLmgXdG5OC9MxVq7w38zigOSX9K8,19527
+chromadb/test/utils/test_result_df_transform.py,sha256=BLPhIxhJOsKS8EHGL6P4qHUldsBtIj0nG9dD75h9K6A,6130
+chromadb/test/utils/test_wait_for_version_increase.py,sha256=oUrUWYtvi5_WfWDwuhg2F0QM5rniIi-9Qzihf8ypF18,1937
+chromadb/test/utils/wait_for_version_increase.py,sha256=xXFD0_0tuV13CGKH5lJyvZkrO-Z8TtG02nS-sIdAI00,1469
+chromadb/types.py,sha256=7AhUjYEkTTq5TBkJ2ZQ3b-SDPwdlZxNIX7GXE7pLDck,10529
+chromadb/utils/__init__.py,sha256=IZ6_vjQ2Qrdkr12ZDZnulDovxD_futgAzhQnm9nNYwo,390
+chromadb/utils/__pycache__/__init__.cpython-313.pyc,,
+chromadb/utils/__pycache__/async_to_sync.cpython-313.pyc,,
+chromadb/utils/__pycache__/batch_utils.cpython-313.pyc,,
+chromadb/utils/__pycache__/data_loaders.cpython-313.pyc,,
+chromadb/utils/__pycache__/delete_file.cpython-313.pyc,,
+chromadb/utils/__pycache__/directory.cpython-313.pyc,,
+chromadb/utils/__pycache__/distance_functions.cpython-313.pyc,,
+chromadb/utils/__pycache__/fastapi.cpython-313.pyc,,
+chromadb/utils/__pycache__/lru_cache.cpython-313.pyc,,
+chromadb/utils/__pycache__/messageid.cpython-313.pyc,,
+chromadb/utils/__pycache__/read_write_lock.cpython-313.pyc,,
+chromadb/utils/__pycache__/rendezvous_hash.cpython-313.pyc,,
+chromadb/utils/__pycache__/results.cpython-313.pyc,,
+chromadb/utils/__pycache__/sparse_embedding_utils.cpython-313.pyc,,
+chromadb/utils/__pycache__/statistics.cpython-313.pyc,,
+chromadb/utils/async_to_sync.py,sha256=-tzc2OvCLk2u8tDRk_ZYySNM7m9HTFvYXqqpwjoDDi4,1741
+chromadb/utils/batch_utils.py,sha256=kAlLWpy20uLyKogWQwTOLx1xl1mLW-r8Hm9d3i0WUW0,1275
+chromadb/utils/data_loaders.py,sha256=75HsZdhGdb6ZOzKXM85Zj2o5_C2ehTM_so8OhDhCIBU,1418
+chromadb/utils/delete_file.py,sha256=3ktMqjkvIuwpFJL5xTOP87V7DG8k9s4RVsuKQXJNA-g,1168
+chromadb/utils/directory.py,sha256=o0SfnZhZ6bf-nLEFwG9LQTHWkxtxJvEioTPx6y7jga4,644
+chromadb/utils/distance_functions.py,sha256=YQ8mbG5EhxmvGKiQekSJpmtmGsRKf3VpojAqYKDAA78,989
+chromadb/utils/embedding_functions/__init__.py,sha256=r9x6-DWHOt61p8wjgJAl6H_tILAhPrNIf4ReUTj59ok,11108
+chromadb/utils/embedding_functions/__pycache__/__init__.cpython-313.pyc,,
+chromadb/utils/embedding_functions/__pycache__/amazon_bedrock_embedding_function.cpython-313.pyc,,
+chromadb/utils/embedding_functions/__pycache__/baseten_embedding_function.cpython-313.pyc,,
+chromadb/utils/embedding_functions/__pycache__/bm25_embedding_function.cpython-313.pyc,,
+chromadb/utils/embedding_functions/__pycache__/chroma_bm25_embedding_function.cpython-313.pyc,,
+chromadb/utils/embedding_functions/__pycache__/chroma_cloud_qwen_embedding_function.cpython-313.pyc,,
+chromadb/utils/embedding_functions/__pycache__/chroma_cloud_splade_embedding_function.cpython-313.pyc,,
+chromadb/utils/embedding_functions/__pycache__/chroma_langchain_embedding_function.cpython-313.pyc,,
+chromadb/utils/embedding_functions/__pycache__/cloudflare_workers_ai_embedding_function.cpython-313.pyc,,
+chromadb/utils/embedding_functions/__pycache__/cohere_embedding_function.cpython-313.pyc,,
+chromadb/utils/embedding_functions/__pycache__/fastembed_sparse_embedding_function.cpython-313.pyc,,
+chromadb/utils/embedding_functions/__pycache__/google_embedding_function.cpython-313.pyc,,
+chromadb/utils/embedding_functions/__pycache__/huggingface_embedding_function.cpython-313.pyc,,
+chromadb/utils/embedding_functions/__pycache__/huggingface_sparse_embedding_function.cpython-313.pyc,,
+chromadb/utils/embedding_functions/__pycache__/instructor_embedding_function.cpython-313.pyc,,
+chromadb/utils/embedding_functions/__pycache__/jina_embedding_function.cpython-313.pyc,,
+chromadb/utils/embedding_functions/__pycache__/mistral_embedding_function.cpython-313.pyc,,
+chromadb/utils/embedding_functions/__pycache__/morph_embedding_function.cpython-313.pyc,,
+chromadb/utils/embedding_functions/__pycache__/nomic_embedding_function.cpython-313.pyc,,
+chromadb/utils/embedding_functions/__pycache__/ollama_embedding_function.cpython-313.pyc,,
+chromadb/utils/embedding_functions/__pycache__/onnx_mini_lm_l6_v2.cpython-313.pyc,,
+chromadb/utils/embedding_functions/__pycache__/open_clip_embedding_function.cpython-313.pyc,,
+chromadb/utils/embedding_functions/__pycache__/openai_embedding_function.cpython-313.pyc,,
+chromadb/utils/embedding_functions/__pycache__/perplexity_embedding_function.cpython-313.pyc,,
+chromadb/utils/embedding_functions/__pycache__/roboflow_embedding_function.cpython-313.pyc,,
+chromadb/utils/embedding_functions/__pycache__/sentence_transformer_embedding_function.cpython-313.pyc,,
+chromadb/utils/embedding_functions/__pycache__/text2vec_embedding_function.cpython-313.pyc,,
+chromadb/utils/embedding_functions/__pycache__/together_ai_embedding_function.cpython-313.pyc,,
+chromadb/utils/embedding_functions/__pycache__/utils.cpython-313.pyc,,
+chromadb/utils/embedding_functions/__pycache__/voyageai_embedding_function.cpython-313.pyc,,
+chromadb/utils/embedding_functions/amazon_bedrock_embedding_function.py,sha256=SNODvsUB2KZ5BQMasoZZ_pnGlX4A1z0IoBKBRXDSE6c,4925
+chromadb/utils/embedding_functions/baseten_embedding_function.py,sha256=kd49KOJpo1jvovzEH6uWIP6Bi4oJHYUK2oHaSwHoTUM,4415
+chromadb/utils/embedding_functions/bm25_embedding_function.py,sha256=x879gRzoYiJP9hc3KOSFGxaH2kWrhv6d4N3dFvQk8yA,8554
+chromadb/utils/embedding_functions/chroma_bm25_embedding_function.py,sha256=tRjDQcQ5lV_KKndELFgLaoyFXoMI2U-GP6jVqIOcngo,5734
+chromadb/utils/embedding_functions/chroma_cloud_qwen_embedding_function.py,sha256=YMTN7bUyWmSoo94Y0lNWd4xRtkYbtOrynEjNR-Gr2Pc,8802
+chromadb/utils/embedding_functions/chroma_cloud_splade_embedding_function.py,sha256=GCb4WVogd5gpOHDvWGpZKUegw04xJ4isJjg_Mfw8lBQ,6989
+chromadb/utils/embedding_functions/chroma_langchain_embedding_function.py,sha256=YjXqx73a8IWHc0HTGn5Ocvk_e9hz-5mxR36L73ym2ZA,6329
+chromadb/utils/embedding_functions/cloudflare_workers_ai_embedding_function.py,sha256=O9tdycBaCRaBec708uuB9F6bvS4BBUE9q-TpU9EJxn8,5558
+chromadb/utils/embedding_functions/cohere_embedding_function.py,sha256=47JnDeo5NyllEi-GO11-YVb42hssvR-4M7DfC67bbFE,6439
+chromadb/utils/embedding_functions/fastembed_sparse_embedding_function.py,sha256=L-HRPk8DCX15DJGGEtqrJu7m-vlTDwW3PZkJ1-I66rM,7433
+chromadb/utils/embedding_functions/google_embedding_function.py,sha256=163Apw3uQ0-ULDTut9r_jfSl4zfQaj9aRZgqowroTGY,24229
+chromadb/utils/embedding_functions/huggingface_embedding_function.py,sha256=ldm_ylb2ZGAj5cbj1pvDBm6kgovAytIBMkZdep7v8eY,8935
+chromadb/utils/embedding_functions/huggingface_sparse_embedding_function.py,sha256=Js7JkZGf_dovMlbrLAVjtrZbUZu6R56JRFYgYMx34U0,7203
+chromadb/utils/embedding_functions/instructor_embedding_function.py,sha256=Rlf0VQL-9Tak58TnabpnBToR2j3AEqQ_-IClS-06-XQ,4362
+chromadb/utils/embedding_functions/jina_embedding_function.py,sha256=xZEHZH3NrUX6aCRvqtEzyGZvu4RCVYq3sgEq5Lu8djQ,10421
+chromadb/utils/embedding_functions/mistral_embedding_function.py,sha256=lLBSsEICieNrdZf7V2Yc0kc7_fAgNBs6NeHFndkhfbg,3215
+chromadb/utils/embedding_functions/morph_embedding_function.py,sha256=r69MICLBGgxkm1tk3DtcOuKpY-QCeuS0ASKxDhIniOw,5437
+chromadb/utils/embedding_functions/nomic_embedding_function.py,sha256=LFZfjj2LVOzulzBIEgGfZaomytdluC3tfVSIdFpdbpI,4585
+chromadb/utils/embedding_functions/ollama_embedding_function.py,sha256=i8f7uyNoqdlUa9x7iyPLl_dZ-xBAJ19QT8WmFIynncQ,4144
+chromadb/utils/embedding_functions/onnx_mini_lm_l6_v2.py,sha256=1Y1HHhwo7GR1Rb5K9ukBpDtd4yTtw1J1OyBsYE1Efa4,14237
+chromadb/utils/embedding_functions/open_clip_embedding_function.py,sha256=aBrD1OFYmUK-yejtd4LW8E1ekUVfN9VlVKVbOO97imw,6257
+chromadb/utils/embedding_functions/openai_embedding_function.py,sha256=sUN8rzcO67GggBkkeXa97k5UxmwrQm3-chzJTMO6HmE,8594
+chromadb/utils/embedding_functions/perplexity_embedding_function.py,sha256=bpzAixs3CuBI0dTE5FaNeC7wc-vE6e-muYabxgS8StM,4840
+chromadb/utils/embedding_functions/roboflow_embedding_function.py,sha256=LkMLWgSdP8kEPZHNFWUY6JtkDpbPva6OE1pZmFerAyE,5347
+chromadb/utils/embedding_functions/schemas/README.md,sha256=WqzNpOY4DEeibmS0OsGnoymJEs8ZfvLTZA7Te68r6a4,1700
+chromadb/utils/embedding_functions/schemas/__init__.py,sha256=_HxywvDCUeM-ur3dDO3Uw24McobRp5nhjgxVl4PQqEY,488
+chromadb/utils/embedding_functions/schemas/__pycache__/__init__.cpython-313.pyc,,
+chromadb/utils/embedding_functions/schemas/__pycache__/bm25_tokenizer.cpython-313.pyc,,
+chromadb/utils/embedding_functions/schemas/__pycache__/registry.cpython-313.pyc,,
+chromadb/utils/embedding_functions/schemas/__pycache__/schema_utils.cpython-313.pyc,,
+chromadb/utils/embedding_functions/schemas/bm25_tokenizer.py,sha256=wFEIvgP1njf1jqnrTLeeffk9zGNiZrTROfLLEUP7XgU,5379
+chromadb/utils/embedding_functions/schemas/registry.py,sha256=jErKQ0kGFl9njyO3qPC9J6VwY8-JXdxHOCkm9_08L04,1654
+chromadb/utils/embedding_functions/schemas/schema_utils.py,sha256=rdXMgZMjEkqM3yiXwVBSloIWUG4Pm7hZF6qIldwcAL4,2675
+chromadb/utils/embedding_functions/sentence_transformer_embedding_function.py,sha256=Xbs3vn2abrxCyuUXrRr0pjpco32ne7CwGELl_EioEKE,4700
+chromadb/utils/embedding_functions/text2vec_embedding_function.py,sha256=CzRI4pkdSidHiE8-CPXAbYYIHFJLW3Y5_a_M-jC5Vwc,3171
+chromadb/utils/embedding_functions/together_ai_embedding_function.py,sha256=r7JUqz77SqlccoV9n_SRCmedg1IwKw923jLD04sU9Zs,4674
+chromadb/utils/embedding_functions/utils.py,sha256=JaeXjODwmDF1QUE9kTbToeOjzLZr9jnM-GCjd-4VNIY,878
+chromadb/utils/embedding_functions/voyageai_embedding_function.py,sha256=H0NXCkvrRnUUG-P79GWRialILzSz9LjGedmcb3RQDD8,5026
+chromadb/utils/fastapi.py,sha256=AtADn2l-t_2oi0a8f2G0SRFoPjP_Mvd-kAKDnbpDF4A,522
+chromadb/utils/lru_cache.py,sha256=T6l1P1n8ym5tq_UwHxLKbCdOq41v4eHEbNvxuRDrIrQ,1108
+chromadb/utils/messageid.py,sha256=0lpBGLqnArIgtZFj7_KTsTHnD9F4wSHw9DKn2weM7_0,280
+chromadb/utils/read_write_lock.py,sha256=VmH6S-Yxo2cU8rN4h5tz5ifEN-SOuMvPszEDJkdGHbc,2084
+chromadb/utils/rendezvous_hash.py,sha256=LcKIkQ1i1xxLBGsJV_Uo9n-5issp6HIdv9NW1spYa_4,2223
+chromadb/utils/results.py,sha256=0TVZZz7rTPrK5Z8pYR1yFwBjALMaMZPcYqs-CUq_IaY,3994
+chromadb/utils/sparse_embedding_utils.py,sha256=mPWQ3ayb5u2qm4n0PL9XnFSx9Nn8IhiLQC1PFfb3sV8,1899
+chromadb/utils/statistics.py,sha256=zLDzY6GUcO01kdiaF_PSnHclSxk4HY4A4weI2r68F4A,9729
+chromadb_rust_bindings/__init__.py,sha256=EQHYniO5ZjnemXFkmB-faa2gCtR8HIke29q6_jaFtkg,171
+chromadb_rust_bindings/__pycache__/__init__.cpython-313.pyc,,
+chromadb_rust_bindings/chromadb_rust_bindings.pyd,sha256=Q-ALJ5K_MbrA6ryFub17BgldtMYcDNrCUkbtWFJiPdU,63397888
+schemas/embedding_functions/README.md,sha256=fLTxt_7M4ivVlawDYFoC2Ns_8bNS0xyEHTb1QfuIL-c,2025
+schemas/embedding_functions/amazon_bedrock.json,sha256=PiV1csj5SV7xPn-mkw8-6OkO3rZym50pOZEcMqZiZ8M,758
+schemas/embedding_functions/base_schema.json,sha256=qCTYjteOlehvXgpIisKThkoe35ahpkO19-Cm7QcPoHI,760
+schemas/embedding_functions/baseten.json,sha256=Of7cIFK_XH1FjgFTqdxp-prHwh2mfx2RYUWJEXkCoIA,687
+schemas/embedding_functions/bm25.json,sha256=zHonkO2ytMTozzvV1T8y8LEmJputAC-epolhh44vja4,3091
+schemas/embedding_functions/chroma-cloud-qwen.json,sha256=fnj4JyNgGukqZpEYA492-utYgxsgsrVziUxuFdEZp0Q,2141
+schemas/embedding_functions/chroma-cloud-splade.json,sha256=IbUxCJ0d1iTGh3-fReMPEhHzRHg1GuzxEZn8mNO8XVI,1061
+schemas/embedding_functions/chroma_bm25.json,sha256=w-6Q8qybuubPRVi8ViSv55iQXZ-rQW-v-3mcAMifo8w,1317
+schemas/embedding_functions/chroma_langchain.json,sha256=Cvr8zbX6Xo_KQJfZ4hz8F7APmR-SyxkXsYCDbRuHWBk,495
+schemas/embedding_functions/cloudflare_workers_ai.json,sha256=LxTVpl-43SMrFv3CaHsTN1F0TUOcKfdO-HHuJNCqvTw,1153
+schemas/embedding_functions/cohere.json,sha256=p0FIdFDd1PMYs7zBDsjStStlfwq81UXzF0qRtqFygaE,703
+schemas/embedding_functions/default.json,sha256=VVIEEUFMFgG_pJarvh-Am3iZsdtmjF8OYOiMDfYZzeo,306
+schemas/embedding_functions/fastembed_sparse.json,sha256=KOfGnxnwm_gHKMJX1sCp-hLpxurmeJr-aMdxojEjG9I,2764
+schemas/embedding_functions/google_gemini.json,sha256=6Gb7Wuecd7dI1MHKwRWQGcWk05zxZYZzDXbNRy8yc_s,1733
+schemas/embedding_functions/google_genai.json,sha256=YGfwSgozGcO7jwS53u0_gdNQO3TzPZQwQbuYVwPB7MM,1670
+schemas/embedding_functions/google_generative_ai.json,sha256=nLWTPWS05V5nsKOreThK5PsEKMZeG7cEnGdr72QNhH0,1016
+schemas/embedding_functions/google_palm.json,sha256=W-1c7nNbTgfmmZ58knikYy18WEGkbnnH2XIKFoSK6UU,650
+schemas/embedding_functions/google_vertex.json,sha256=n-goY_lF8mXuitGM0-9APwksvQ9Px2SCKPYWedR9JZk,894
+schemas/embedding_functions/huggingface.json,sha256=WdUNPbGax-Lhsg7vJFhLcgotQxiLCzJJ6cTxEckqNz8,718
+schemas/embedding_functions/huggingface_server.json,sha256=HJ5P6uEJHJ1Fkccvd5fbyjU8KThNCsf73HBdqE6Ej2E,730
+schemas/embedding_functions/huggingface_sparse.json,sha256=nqEAGbJ0ia9pAh8kbLhAmtIXqKt7wWFeYQel_Da5wmk,1934
+schemas/embedding_functions/instructor.json,sha256=6wUCm0P17tFEbrPMvZPWpe7oAcv4uAhE-3plR1GPcqA,794
+schemas/embedding_functions/jina.json,sha256=v-icONTSL0YtepqGXRXdcG533ZMVKafC9Z8c-QZ0Q9E,1803
+schemas/embedding_functions/mistral.json,sha256=KlEJEYq9BjMbQbo5ONmTMiylMjZhRZoCBPqHpIn3icE,616
+schemas/embedding_functions/morph.json,sha256=5h4G4dkr6ELsxYrc-XsMN8jGBL4qLggXD3cJgNqqHxE,1085
+schemas/embedding_functions/nomic.json,sha256=eq7L_5PpyLdHTSBg5XmtqhHRxtMH0qNGgBAwUK4uGj0,720
+schemas/embedding_functions/ollama.json,sha256=CaSlvOeRiZ7gLd26A1tydd4tIZl9A1zysRUS8E3siTU,678
+schemas/embedding_functions/onnx_mini_lm_l6_v2.json,sha256=45jqAKuaFS3WLXp_IeUUsfhSKZd6lcqxaCCcya43OzY,584
+schemas/embedding_functions/open_clip.json,sha256=1DDhVwK5P2YB7CsEhFB9xvvxDx5p0m7PSaOIkvalumo,806
+schemas/embedding_functions/openai.json,sha256=jyne1EXhMFZy7fSFpbxbWB3iknHd22ma5cEzi7HzqUQ,2076
+schemas/embedding_functions/perplexity.json,sha256=O364Bt_CSsIOQK-ZpmHzGPzaVe4kAenEwABT4VsuM38,781
+schemas/embedding_functions/roboflow.json,sha256=iKZUOAfiPBBpI6ioLhmqfHX7neX3HHGI9D-oNFZYnGI,628
+schemas/embedding_functions/sentence_transformer.json,sha256=NOXMNjNQbbmNH-LWW31lsWbJSr-RAj3PFAuTqDREUCE,1285
+schemas/embedding_functions/text2vec.json,sha256=ZK2jKB7c0cYJSPd1lrCWODrq8OJOnV-pdXun0uqheE8,468
+schemas/embedding_functions/together_ai.json,sha256=LQ6v1K8nG2uzDNm92PTDeG9jmcOWdVQ6p3NltPhNs8U,722
+schemas/embedding_functions/transformers.json,sha256=_qxdfcEbBy6tsa0eqVU4gURmY1lxkcj3i-94msF0IYU,863
+schemas/embedding_functions/voyageai.json,sha256=P7fx6C45V42A8X-rUUqk4AKSMFTc7eHPZLZYGvRi02k,945
diff --git a/python/user_packages/Python313/site-packages/chromadb-1.5.9.dist-info/REQUESTED b/python/user_packages/Python313/site-packages/chromadb-1.5.9.dist-info/REQUESTED
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/python/user_packages/Python313/site-packages/chromadb-1.5.9.dist-info/WHEEL b/python/user_packages/Python313/site-packages/chromadb-1.5.9.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..70fe362c3963492b9ab1d9362353fe988c3fc81d
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/chromadb-1.5.9.dist-info/WHEEL
@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.13.1)
+Root-Is-Purelib: false
+Tag: cp39-abi3-win_amd64
diff --git a/python/user_packages/Python313/site-packages/chromadb-1.5.9.dist-info/entry_points.txt b/python/user_packages/Python313/site-packages/chromadb-1.5.9.dist-info/entry_points.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3382f8256293610db64e7a5ef9ccd13e5a5d0a09
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/chromadb-1.5.9.dist-info/entry_points.txt
@@ -0,0 +1,2 @@
+[console_scripts]
+chroma=chromadb.cli.cli:app
diff --git a/python/user_packages/Python313/site-packages/chromadb/__init__.py b/python/user_packages/Python313/site-packages/chromadb/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a732a19263a2cfc3bd588f1a2fe6ca1f2baa11f1
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/chromadb/__init__.py
@@ -0,0 +1,467 @@
+from typing import Dict, Optional, Union
+
+__version__ = "1.5.9"
+
+import logging
+from chromadb.api.client import Client as ClientCreator
+from chromadb.api.client import (
+ AdminClient as AdminClientCreator,
+)
+from chromadb.api.async_client import AsyncClient as AsyncClientCreator
+from chromadb.auth.token_authn import TokenTransportHeader
+import chromadb.config
+from chromadb.config import DEFAULT_DATABASE, DEFAULT_TENANT, Settings
+from chromadb.api import AdminAPI, AsyncClientAPI, ClientAPI
+from chromadb.api.models.Collection import Collection
+from chromadb.api.types import (
+ Cmek,
+ CollectionMetadata,
+ UpdateMetadata,
+ Documents,
+ EmbeddingFunction,
+ Embeddings,
+ URI,
+ URIs,
+ IDs,
+ Include,
+ Metadata,
+ Metadatas,
+ ReadLevel,
+ Where,
+ QueryResult,
+ GetResult,
+ WhereDocument,
+ UpdateCollectionMetadata,
+ SparseVector,
+ SparseVectors,
+ SparseEmbeddingFunction,
+ Schema,
+ VectorIndexConfig,
+ HnswIndexConfig,
+ SpannIndexConfig,
+ FtsIndexConfig,
+ SparseVectorIndexConfig,
+ StringInvertedIndexConfig,
+ IntInvertedIndexConfig,
+ FloatInvertedIndexConfig,
+ BoolInvertedIndexConfig,
+)
+
+# Import Search API components
+from chromadb.execution.expression.plan import Search
+from chromadb.execution.expression.operator import (
+ # Key builder for where conditions and field selection
+ Key,
+ K, # Alias for Key
+ # KNN-based ranking for hybrid search
+ Knn,
+ # Reciprocal Rank Fusion for combining rankings
+ Rrf,
+)
+from pathlib import Path
+import os
+
+# Re-export types from chromadb.types
+__all__ = [
+ "Cmek",
+ "Collection",
+ "Metadata",
+ "Metadatas",
+ "Where",
+ "WhereDocument",
+ "Documents",
+ "IDs",
+ "URI",
+ "URIs",
+ "Embeddings",
+ "EmbeddingFunction",
+ "Include",
+ "CollectionMetadata",
+ "UpdateMetadata",
+ "UpdateCollectionMetadata",
+ "QueryResult",
+ "GetResult",
+ "TokenTransportHeader",
+ # Search API components
+ "Search",
+ "Key",
+ "K",
+ "Knn",
+ "Rrf",
+ # Sparse Vector Types
+ "SparseVector",
+ "SparseVectors",
+ "SparseEmbeddingFunction",
+ # Schema and Index Configuration
+ "Schema",
+ "VectorIndexConfig",
+ "HnswIndexConfig",
+ "SpannIndexConfig",
+ "FtsIndexConfig",
+ "SparseVectorIndexConfig",
+ "StringInvertedIndexConfig",
+ "IntInvertedIndexConfig",
+ "FloatInvertedIndexConfig",
+ "BoolInvertedIndexConfig",
+]
+
+from chromadb.types import CloudClientArg
+
+logger = logging.getLogger(__name__)
+
+__settings = Settings()
+
+
+
+# Workaround to deal with Colab's old sqlite3 version
+def is_in_colab() -> bool:
+ try:
+ import google.colab # noqa: F401
+
+ return True
+ except ImportError:
+ return False
+
+
+IN_COLAB = is_in_colab()
+
+is_client = False
+try:
+ from chromadb.is_thin_client import is_thin_client
+
+ is_client = is_thin_client
+except ImportError:
+ is_client = False
+
+if not is_client:
+ import sqlite3
+
+ if sqlite3.sqlite_version_info < (3, 35, 0):
+ if IN_COLAB:
+ # In Colab, hotswap to pysqlite-binary if it's too old
+ import subprocess
+ import sys
+
+ subprocess.check_call(
+ [sys.executable, "-m", "pip", "install", "pysqlite3-binary"]
+ )
+ __import__("pysqlite3")
+ sys.modules["sqlite3"] = sys.modules.pop("pysqlite3")
+ else:
+ raise RuntimeError(
+ "\033[91mYour system has an unsupported version of sqlite3. Chroma \
+ requires sqlite3 >= 3.35.0.\033[0m\n"
+ "\033[94mPlease visit \
+ https://docs.trychroma.com/troubleshooting#sqlite to learn how \
+ to upgrade.\033[0m"
+ )
+
+
+def configure(**kwargs) -> None: # type: ignore
+ """Override Chroma's default settings, environment variables or .env files"""
+ global __settings
+ __settings = chromadb.config.Settings(**kwargs)
+
+
+def get_settings() -> Settings:
+ return __settings
+
+
+def EphemeralClient(
+ settings: Optional[Settings] = None,
+ tenant: str = DEFAULT_TENANT,
+ database: str = DEFAULT_DATABASE,
+) -> ClientAPI:
+ """Create an in-memory client for local use.
+
+ This client stores all data in memory and does not persist to disk.
+ It is intended for testing and development.
+
+ Args:
+ settings: Optional settings to override defaults.
+ tenant: Tenant name to use for requests. Defaults to the default tenant.
+ database: Database name to use for requests. Defaults to the default database.
+
+ Returns:
+ ClientAPI: A configured client instance.
+ """
+ if settings is None:
+ settings = Settings()
+ settings.is_persistent = False
+
+ # Make sure paramaters are the correct types -- users can pass anything.
+ tenant = str(tenant)
+ database = str(database)
+
+ return ClientCreator(settings=settings, tenant=tenant, database=database)
+
+
+def PersistentClient(
+ path: Union[str, Path] = "./chroma",
+ settings: Optional[Settings] = None,
+ tenant: str = DEFAULT_TENANT,
+ database: str = DEFAULT_DATABASE,
+) -> ClientAPI:
+ """Create a persistent client that stores data on disk.
+
+ This client is intended for local development and testing. For production,
+ prefer a server-backed Chroma instance.
+
+ Args:
+ path: Directory to store persisted data.
+ settings: Optional settings to override defaults.
+ tenant: Tenant name to use for requests.
+ database: Database name to use for requests.
+
+ Returns:
+ ClientAPI: A configured client instance.
+ """
+ if settings is None:
+ settings = Settings()
+ settings.persist_directory = str(path)
+ settings.is_persistent = True
+
+ # Make sure paramaters are the correct types -- users can pass anything.
+ tenant = str(tenant)
+ database = str(database)
+
+ return ClientCreator(tenant=tenant, database=database, settings=settings)
+
+
+def RustClient(
+ path: Optional[str] = None,
+ settings: Optional[Settings] = None,
+ tenant: str = DEFAULT_TENANT,
+ database: str = DEFAULT_DATABASE,
+) -> ClientAPI:
+ """
+ Creates an ephemeral or persistance instance of Chroma that saves to disk.
+ This is useful for testing and development, but not recommended for production use.
+
+ Args:
+ path: An optional directory to save Chroma's data to. The client is ephemeral if a None value is provided. Defaults to None.
+ tenant: The tenant to use for this client.
+ database: The database to use for this client.
+ """
+ if settings is None:
+ settings = Settings()
+
+ settings.chroma_api_impl = "chromadb.api.rust.RustBindingsAPI"
+ settings.is_persistent = path is not None
+ settings.persist_directory = path or ""
+
+ # Make sure paramaters are the correct types -- users can pass anything.
+ tenant = str(tenant)
+ database = str(database)
+
+ return ClientCreator(tenant=tenant, database=database, settings=settings)
+
+
+def HttpClient(
+ host: str = "localhost",
+ port: int = 8000,
+ ssl: bool = False,
+ headers: Optional[Dict[str, str]] = None,
+ settings: Optional[Settings] = None,
+ tenant: str = DEFAULT_TENANT,
+ database: str = DEFAULT_DATABASE,
+) -> ClientAPI:
+ """Create a client that connects to a Chroma server.
+
+ Args:
+ host: Hostname of the Chroma server.
+ port: HTTP port of the Chroma server.
+ ssl: Whether to enable SSL for the connection.
+ headers: Optional headers to send with each request.
+ settings: Optional settings to override defaults.
+ tenant: Tenant name to use for requests.
+ database: Database name to use for requests.
+
+ Returns:
+ ClientAPI: A configured client instance.
+
+ Raises:
+ ValueError: If settings specify a different host or port.
+ """
+
+ if settings is None:
+ settings = Settings()
+
+ # Make sure parameters are the correct types -- users can pass anything.
+ host = str(host)
+ port = int(port)
+ ssl = bool(ssl)
+ tenant = str(tenant)
+ database = str(database)
+
+ settings.chroma_api_impl = "chromadb.api.fastapi.FastAPI"
+ if settings.chroma_server_host and settings.chroma_server_host != host:
+ raise ValueError(
+ f"Chroma server host provided in settings[{settings.chroma_server_host}] is different to the one provided in HttpClient: [{host}]"
+ )
+ settings.chroma_server_host = host
+ if settings.chroma_server_http_port and settings.chroma_server_http_port != port:
+ raise ValueError(
+ f"Chroma server http port provided in settings[{settings.chroma_server_http_port}] is different to the one provided in HttpClient: [{port}]"
+ )
+ settings.chroma_server_http_port = port
+ settings.chroma_server_ssl_enabled = ssl
+ settings.chroma_server_headers = headers
+
+ return ClientCreator(tenant=tenant, database=database, settings=settings)
+
+
+async def AsyncHttpClient(
+ host: str = "localhost",
+ port: int = 8000,
+ ssl: bool = False,
+ headers: Optional[Dict[str, str]] = None,
+ settings: Optional[Settings] = None,
+ tenant: str = DEFAULT_TENANT,
+ database: str = DEFAULT_DATABASE,
+) -> AsyncClientAPI:
+ """Create an async client that connects to a Chroma HTTP server.
+
+ This supports multiple clients connecting to the same server and is the
+ recommended production configuration.
+
+ Args:
+ host: Hostname of the Chroma server.
+ port: HTTP port of the Chroma server.
+ ssl: Whether to enable SSL for the connection.
+ headers: Optional headers to send with each request.
+ settings: Optional settings to override defaults.
+ tenant: Tenant name to use for requests.
+ database: Database name to use for requests.
+
+ Returns:
+ AsyncClientAPI: A configured async client instance.
+
+ Raises:
+ ValueError: If settings specify a different host or port.
+ """
+
+ if settings is None:
+ settings = Settings()
+
+ # Make sure parameters are the correct types -- users can pass anything.
+ host = str(host)
+ port = int(port)
+ ssl = bool(ssl)
+ tenant = str(tenant)
+ database = str(database)
+
+ settings.chroma_api_impl = "chromadb.api.async_fastapi.AsyncFastAPI"
+ if settings.chroma_server_host and settings.chroma_server_host != host:
+ raise ValueError(
+ f"Chroma server host provided in settings[{settings.chroma_server_host}] is different to the one provided in HttpClient: [{host}]"
+ )
+ settings.chroma_server_host = host
+ if settings.chroma_server_http_port and settings.chroma_server_http_port != port:
+ raise ValueError(
+ f"Chroma server http port provided in settings[{settings.chroma_server_http_port}] is different to the one provided in HttpClient: [{port}]"
+ )
+ settings.chroma_server_http_port = port
+ settings.chroma_server_ssl_enabled = ssl
+ settings.chroma_server_headers = headers
+
+ return await AsyncClientCreator.create(
+ tenant=tenant, database=database, settings=settings
+ )
+
+
+def CloudClient(
+ tenant: Optional[str] = None,
+ database: Optional[str] = None,
+ api_key: Optional[str] = None,
+ settings: Optional[Settings] = None,
+ *, # Following arguments are keyword-only, intended for testing only.
+ cloud_host: str = "api.trychroma.com",
+ cloud_port: int = 443,
+ enable_ssl: bool = True,
+) -> ClientAPI:
+ """Create a client for Chroma Cloud.
+
+ If not provided, `tenant`, `database`, and `api_key` will be inferred from the environment variables `CHROMA_TENANT`, `CHROMA_DATABASE`, and `CHROMA_API_KEY`.
+
+ Args:
+ tenant: Tenant name to use, or None to infer from credentials.
+ database: Database name to use, or None to infer from credentials.
+ api_key: API key for Chroma Cloud.
+ settings: Optional settings to override defaults.
+
+ Returns:
+ ClientAPI: A configured client instance.
+
+ Raises:
+ ValueError: If no API key is provided or available in the environment.
+ """
+
+ required_args = [
+ CloudClientArg(name="api_key", env_var="CHROMA_API_KEY", value=api_key),
+ ]
+
+ # If api_key is not provided, try to load it from the environment variable
+ if not all([arg.value for arg in required_args]):
+ for arg in required_args:
+ arg.value = arg.value or os.environ.get(arg.env_var)
+
+ missing_args = [arg for arg in required_args if arg.value is None]
+ if missing_args:
+ raise ValueError(
+ f"Missing required arguments: {', '.join([arg.name for arg in missing_args])}. "
+ f"Please provide them or set the environment variables: {', '.join([arg.env_var for arg in missing_args])}"
+ )
+
+ if settings is None:
+ settings = Settings()
+
+ # Make sure paramaters are the correct types -- users can pass anything.
+ tenant = tenant or os.environ.get("CHROMA_TENANT")
+ if tenant is not None:
+ tenant = str(tenant)
+ database = database or os.environ.get("CHROMA_DATABASE")
+ if database is not None:
+ database = str(database)
+ api_key = str(api_key)
+ cloud_host = str(cloud_host)
+ cloud_port = int(cloud_port)
+ enable_ssl = bool(enable_ssl)
+
+ settings.chroma_api_impl = "chromadb.api.fastapi.FastAPI"
+ settings.chroma_server_host = cloud_host
+ settings.chroma_server_http_port = cloud_port
+ settings.chroma_server_ssl_enabled = enable_ssl
+
+ settings.chroma_client_auth_provider = (
+ "chromadb.auth.token_authn.TokenAuthClientProvider"
+ )
+ settings.chroma_client_auth_credentials = api_key
+ settings.chroma_auth_token_transport_header = TokenTransportHeader.X_CHROMA_TOKEN
+ settings.chroma_overwrite_singleton_tenant_database_access_from_auth = True
+
+ return ClientCreator(tenant=tenant, database=database, settings=settings)
+
+
+def Client(
+ settings: Settings = __settings,
+ tenant: str = DEFAULT_TENANT,
+ database: str = DEFAULT_DATABASE,
+) -> ClientAPI:
+ """
+ Return a running chroma.API instance
+
+ tenant: The tenant to use for this client. Defaults to the default tenant.
+ database: The database to use for this client. Defaults to the default database.
+ """
+
+ # Make sure paramaters are the correct types -- users can pass anything.
+ tenant = str(tenant)
+ database = str(database)
+
+ return ClientCreator(tenant=tenant, database=database, settings=settings)
+
+
+def AdminClient(settings: Settings = Settings()) -> AdminAPI:
+ """Create an admin client for tenant and database management."""
+ return AdminClientCreator(settings=settings)
diff --git a/python/user_packages/Python313/site-packages/chromadb/app.py b/python/user_packages/Python313/site-packages/chromadb/app.py
new file mode 100644
index 0000000000000000000000000000000000000000..9e87ef0411fd375d95a884235536761bcc47c300
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/chromadb/app.py
@@ -0,0 +1,7 @@
+import chromadb
+import chromadb.config
+from chromadb.server.fastapi import FastAPI
+
+settings = chromadb.config.Settings()
+server = FastAPI(settings)
+app = server.app()
diff --git a/python/user_packages/Python313/site-packages/chromadb/base_types.py b/python/user_packages/Python313/site-packages/chromadb/base_types.py
new file mode 100644
index 0000000000000000000000000000000000000000..8f892b51dd61974e3225257abed45e691cf9bcf3
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/chromadb/base_types.py
@@ -0,0 +1,158 @@
+from typing import Dict, List, Mapping, Optional, Sequence, Union, Any
+from typing_extensions import Literal, Final
+from dataclasses import dataclass
+import numpy as np
+from numpy.typing import NDArray
+
+# Type tag constants
+TYPE_KEY: Final[str] = "#type"
+SPARSE_VECTOR_TYPE_VALUE: Final[str] = "sparse_vector"
+
+
+@dataclass
+class SparseVector:
+ """Sparse vector using parallel indices and values arrays.
+
+ Attributes:
+ indices: List of dimension indices (must be non-negative integers, sorted in strictly ascending order)
+ values: List of values corresponding to each index (floats)
+ labels: Optional list of string labels corresponding to each index
+
+ Note:
+ - Indices must be sorted in strictly ascending order (no duplicates)
+ - Indices and values must have the same length
+ - If labels is provided, it must have the same length as indices and values
+ - All validations are performed in __post_init__
+ """
+
+ indices: List[int]
+ values: List[float]
+ labels: Optional[List[str]] = None
+
+ def __post_init__(self) -> None:
+ """Validate sparse vector structure."""
+ if not isinstance(self.indices, list):
+ raise ValueError(
+ f"Expected SparseVector indices to be a list, got {type(self.indices).__name__}"
+ )
+
+ if not isinstance(self.values, list):
+ raise ValueError(
+ f"Expected SparseVector values to be a list, got {type(self.values).__name__}"
+ )
+
+ if len(self.indices) != len(self.values):
+ raise ValueError(
+ f"SparseVector indices and values must have the same length, "
+ f"got {len(self.indices)} indices and {len(self.values)} values"
+ )
+
+ if self.labels is not None:
+ if not isinstance(self.labels, list):
+ raise ValueError(
+ f"Expected SparseVector labels to be a list, got {type(self.labels).__name__}"
+ )
+ if len(self.labels) != len(self.indices):
+ raise ValueError(
+ f"SparseVector labels must have the same length as indices and values, "
+ f"got {len(self.labels)} labels, {len(self.indices)} indices"
+ )
+
+ for i, idx in enumerate(self.indices):
+ if not isinstance(idx, int):
+ raise ValueError(
+ f"SparseVector indices must be integers, got {type(idx).__name__} at position {i}"
+ )
+ if idx < 0:
+ raise ValueError(
+ f"SparseVector indices must be non-negative, got {idx} at position {i}"
+ )
+
+ for i, val in enumerate(self.values):
+ if not isinstance(val, (int, float)):
+ raise ValueError(
+ f"SparseVector values must be numbers, got {type(val).__name__} at position {i}"
+ )
+
+ # Validate indices are sorted in strictly ascending order
+ if len(self.indices) > 1:
+ for i in range(1, len(self.indices)):
+ if self.indices[i] <= self.indices[i - 1]:
+ raise ValueError(
+ f"SparseVector indices must be sorted in strictly ascending order, "
+ f"found indices[{i}]={self.indices[i]} <= indices[{i-1}]={self.indices[i-1]}"
+ )
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Serialize to transport format with type tag.
+
+ Note: Uses 'tokens' as the wire format key name for compatibility
+ with the protobuf schema, even though the Python attribute is 'labels'.
+ """
+ result = {
+ TYPE_KEY: SPARSE_VECTOR_TYPE_VALUE,
+ "indices": self.indices,
+ "values": self.values,
+ }
+ if self.labels is not None:
+ result["tokens"] = self.labels # Wire format uses 'tokens'
+ return result
+
+ @classmethod
+ def from_dict(cls, d: Dict[str, Any]) -> "SparseVector":
+ """Deserialize from transport format (strict - requires #type field).
+
+ Note: Reads from 'tokens' key in the wire format for compatibility
+ with the protobuf schema, mapping it to the 'labels' attribute.
+ """
+ if d.get(TYPE_KEY) != SPARSE_VECTOR_TYPE_VALUE:
+ raise ValueError(
+ f"Expected {TYPE_KEY}='{SPARSE_VECTOR_TYPE_VALUE}', got {d.get(TYPE_KEY)}"
+ )
+ return cls(
+ indices=d["indices"],
+ values=d["values"],
+ labels=d.get("tokens"), # Wire format uses 'tokens'
+ )
+
+
+MetadataListValue = List[Union[str, int, float, bool]]
+Metadata = Mapping[
+ str, Optional[Union[str, int, float, bool, SparseVector, MetadataListValue]]
+]
+UpdateMetadata = Mapping[
+ str, Union[int, float, str, bool, SparseVector, MetadataListValue, None]
+]
+PyVector = Union[Sequence[float], Sequence[int]]
+Vector = NDArray[Union[np.int32, np.float32]] # TODO: Specify that the vector is 1D
+# Metadata Query Grammar
+LiteralValue = Union[str, int, float, bool]
+LogicalOperator = Union[Literal["$and"], Literal["$or"]]
+WhereOperator = Union[
+ Literal["$gt"],
+ Literal["$gte"],
+ Literal["$lt"],
+ Literal["$lte"],
+ Literal["$ne"],
+ Literal["$eq"],
+]
+InclusionExclusionOperator = Union[Literal["$in"], Literal["$nin"]]
+ArrayContainsOperator = Union[Literal["$contains"], Literal["$not_contains"]]
+OperatorExpression = Union[
+ Dict[Union[WhereOperator, LogicalOperator], LiteralValue],
+ Dict[InclusionExclusionOperator, List[LiteralValue]],
+ Dict[ArrayContainsOperator, LiteralValue],
+]
+
+Where = Dict[
+ Union[str, LogicalOperator], Union[LiteralValue, OperatorExpression, List["Where"]]
+]
+
+WhereDocumentOperator = Union[
+ Literal["$contains"],
+ Literal["$not_contains"],
+ Literal["$regex"],
+ Literal["$not_regex"],
+ LogicalOperator,
+]
+WhereDocument = Dict[WhereDocumentOperator, Union[str, List["WhereDocument"]]]
diff --git a/python/user_packages/Python313/site-packages/chromadb/chromadb_rust_bindings.pyi b/python/user_packages/Python313/site-packages/chromadb/chromadb_rust_bindings.pyi
new file mode 100644
index 0000000000000000000000000000000000000000..80ff162f415bd92eda6d080a52e0d9384e43bdfd
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/chromadb/chromadb_rust_bindings.pyi
@@ -0,0 +1,201 @@
+from typing import List, Optional, Sequence
+from uuid import UUID
+from chromadb import CollectionMetadata, Embeddings, IDs
+from chromadb.api.types import (
+ CollectionMetadata,
+ Documents,
+ Embeddings,
+ IDs,
+ Metadatas,
+ URIs,
+ Include,
+)
+from chromadb.types import Tenant, Collection as CollectionModel
+from chromadb.config import DEFAULT_DATABASE, DEFAULT_TENANT
+from enum import Enum
+
+class DatabaseFromBindings:
+ id: UUID
+ name: str
+ tenant: str
+
+# Result Types
+
+class GetResponse:
+ ids: IDs
+ embeddings: Embeddings
+ documents: Documents
+ uris: URIs
+ metadatas: Metadatas
+ include: Include
+
+class QueryResponse:
+ ids: List[IDs]
+ embeddings: Optional[List[Embeddings]]
+ documents: Optional[List[Documents]]
+ uris: Optional[List[URIs]]
+ metadatas: Optional[List[Metadatas]]
+ distances: Optional[List[List[float]]]
+ include: Include
+
+class GetTenantResponse:
+ name: str
+
+# SqliteDBConfig types
+class MigrationMode(Enum):
+ Apply = 0
+ Validate = 1
+
+class MigrationHash(Enum):
+ SHA256 = 0
+ MD5 = 1
+
+class SqliteDBConfig:
+ url: str
+ hash_type: MigrationHash
+ migration_mode: MigrationMode
+
+ def __init__(
+ self, url: str, hash_type: MigrationHash, migration_mode: MigrationMode
+ ) -> None: ...
+
+class Bindings:
+ def __init__(
+ self,
+ allow_reset: bool,
+ sqlite_db_config: SqliteDBConfig,
+ persist_path: str,
+ hnsw_cache_size: int,
+ ) -> None: ...
+ def heartbeat(self) -> int: ...
+ def create_database(self, name: str, tenant: str = DEFAULT_TENANT) -> None: ...
+ def get_database(
+ self, name: str, tenant: str = DEFAULT_TENANT
+ ) -> DatabaseFromBindings: ...
+ def delete_database(self, name: str, tenant: str = DEFAULT_TENANT) -> None: ...
+ def list_databases(
+ self,
+ limit: Optional[int] = None,
+ offset: Optional[int] = None,
+ tenant: str = DEFAULT_TENANT,
+ ) -> Sequence[DatabaseFromBindings]: ...
+ def create_tenant(self, name: str) -> None: ...
+ def get_tenant(self, name: str) -> GetTenantResponse: ...
+ def count_collections(
+ self, tenant: str = DEFAULT_TENANT, database: str = DEFAULT_DATABASE
+ ) -> int: ...
+ def list_collections(
+ self,
+ limit: Optional[int] = None,
+ offset: Optional[int] = None,
+ tenant: str = DEFAULT_TENANT,
+ database: str = DEFAULT_DATABASE,
+ ) -> Sequence[CollectionModel]: ...
+ def create_collection(
+ self,
+ name: str,
+ configuration_json_str: Optional[str] = None,
+ schema_str: Optional[str] = None,
+ metadata: Optional[CollectionMetadata] = None,
+ get_or_create: bool = False,
+ tenant: str = DEFAULT_TENANT,
+ database: str = DEFAULT_DATABASE,
+ ) -> CollectionModel: ...
+ def get_collection(
+ self,
+ name: str,
+ tenant: str = DEFAULT_TENANT,
+ database: str = DEFAULT_DATABASE,
+ ) -> CollectionModel: ...
+ def get_collection_by_id(
+ self,
+ collection_id: str,
+ tenant: str = DEFAULT_TENANT,
+ database: str = DEFAULT_DATABASE,
+ ) -> CollectionModel: ...
+ def update_collection(
+ self,
+ id: str,
+ new_name: Optional[str] = None,
+ new_metadata: Optional[CollectionMetadata] = None,
+ new_configuration_json_str: Optional[str] = None,
+ ) -> None: ...
+ def delete_collection(
+ self,
+ name: str,
+ tenant: str = DEFAULT_TENANT,
+ database: str = DEFAULT_DATABASE,
+ ) -> None: ...
+ def add(
+ self,
+ ids: IDs,
+ collection_id: str,
+ embeddings: Embeddings,
+ metadatas: Optional[Metadatas] = None,
+ documents: Optional[Documents] = None,
+ uris: Optional[URIs] = None,
+ tenant: str = DEFAULT_TENANT,
+ database: str = DEFAULT_DATABASE,
+ ) -> bool: ...
+ def update(
+ self,
+ collection_id: str,
+ ids: IDs,
+ embeddings: Optional[Embeddings] = None,
+ metadatas: Optional[Metadatas] = None,
+ documents: Optional[Documents] = None,
+ uris: Optional[URIs] = None,
+ tenant: str = DEFAULT_TENANT,
+ database: str = DEFAULT_DATABASE,
+ ) -> bool: ...
+ def upsert(
+ self,
+ collection_id: str,
+ ids: IDs,
+ embeddings: Embeddings,
+ metadatas: Optional[Metadatas] = None,
+ documents: Optional[Documents] = None,
+ uris: Optional[URIs] = None,
+ tenant: str = DEFAULT_TENANT,
+ database: str = DEFAULT_DATABASE,
+ ) -> bool: ...
+ def delete(
+ self,
+ collection_id: str,
+ ids: Optional[IDs] = None,
+ where: Optional[str] = None,
+ where_document: Optional[str] = None,
+ tenant: str = DEFAULT_TENANT,
+ database: str = DEFAULT_DATABASE,
+ ) -> None: ...
+ def count(
+ self,
+ collection_id: str,
+ tenant: str = DEFAULT_TENANT,
+ database: str = DEFAULT_DATABASE,
+ ) -> int: ...
+ def get(
+ self,
+ collection_id: str,
+ ids: Optional[IDs] = None,
+ where: Optional[str] = None,
+ limit: Optional[int] = None,
+ offset: Optional[int] = None,
+ where_document: Optional[str] = None,
+ include: Include = ["metadatas", "documents"], # type: ignore[list-item]
+ tenant: str = DEFAULT_TENANT,
+ database: str = DEFAULT_DATABASE,
+ ) -> GetResponse: ...
+ def query(
+ self,
+ collection_id: str,
+ query_embeddings: Embeddings,
+ n_results: int = 10,
+ where: Optional[str] = None,
+ where_document: Optional[str] = None,
+ include: Include = ["metadatas", "documents", "distances"], # type: ignore[list-item]
+ tenant: str = DEFAULT_TENANT,
+ database: str = DEFAULT_DATABASE,
+ ) -> QueryResponse: ...
+ def reset(self) -> bool: ...
+ def get_version(self) -> str: ...
diff --git a/python/user_packages/Python313/site-packages/chromadb/config.py b/python/user_packages/Python313/site-packages/chromadb/config.py
new file mode 100644
index 0000000000000000000000000000000000000000..7661eeb55cebb0cf7e51e859b3edce78bd8427af
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/chromadb/config.py
@@ -0,0 +1,499 @@
+import importlib
+import inspect
+import logging
+from abc import ABC
+from enum import Enum
+from graphlib import TopologicalSorter
+from typing import Optional, List, Any, Dict, Set, Iterable, Union
+from typing import Type, TypeVar, cast
+
+from overrides import EnforceOverrides
+from overrides import override
+from typing_extensions import Literal
+import platform
+
+from pydantic import field_validator
+from pydantic_settings import BaseSettings
+
+# The thin client will have a flag to control which implementations to use
+is_thin_client = False
+try:
+ from chromadb.is_thin_client import is_thin_client # type: ignore
+except ImportError:
+ is_thin_client = False
+
+logger = logging.getLogger(__name__)
+
+LEGACY_ERROR = """\033[91mYou are using a deprecated configuration of Chroma.
+
+\033[94mIf you do not have data you wish to migrate, you only need to change how you construct
+your Chroma client. Please see the "New Clients" section of https://docs.trychroma.com/deployment/migration.
+________________________________________________________________________________________________
+
+If you do have data you wish to migrate, we have a migration tool you can use in order to
+migrate your data to the new Chroma architecture.
+Please `pip install chroma-migrate` and run `chroma-migrate` to migrate your data and then
+change how you construct your Chroma client.
+
+See https://docs.trychroma.com/deployment/migration for more information or join our discord at https://discord.gg/MMeYNTmh3x for help!\033[0m"""
+
+_legacy_config_keys = {
+ "chroma_db_impl",
+}
+
+_legacy_config_values = {
+ "duckdb",
+ "duckdb+parquet",
+ "clickhouse",
+ "local",
+ "rest",
+ "chromadb.db.duckdb.DuckDB",
+ "chromadb.db.duckdb.PersistentDuckDB",
+ "chromadb.db.clickhouse.Clickhouse",
+ "chromadb.api.local.LocalAPI",
+}
+
+
+# Map specific abstract types to the setting which specifies which
+# concrete implementation to use.
+# Please keep these sorted. We're civilized people.
+_abstract_type_keys: Dict[str, str] = {
+ # TODO: Don't use concrete types here to avoid circular deps. Strings are
+ # fine for right here!
+ # NOTE: this is to support legacy api construction. Use ServerAPI instead
+ "chromadb.api.API": "chroma_api_impl",
+ "chromadb.api.ServerAPI": "chroma_api_impl",
+ "chromadb.api.async_api.AsyncServerAPI": "chroma_api_impl",
+ "chromadb.auth.ClientAuthProvider": "chroma_client_auth_provider",
+ "chromadb.auth.ServerAuthenticationProvider": "chroma_server_authn_provider",
+ "chromadb.auth.ServerAuthorizationProvider": "chroma_server_authz_provider",
+ "chromadb.db.system.SysDB": "chroma_sysdb_impl",
+ "chromadb.execution.executor.abstract.Executor": "chroma_executor_impl",
+ "chromadb.ingest.Consumer": "chroma_consumer_impl",
+ "chromadb.ingest.Producer": "chroma_producer_impl",
+ "chromadb.quota.QuotaEnforcer": "chroma_quota_enforcer_impl",
+ "chromadb.rate_limit.RateLimitEnforcer": "chroma_rate_limit_enforcer_impl",
+ "chromadb.rate_limit.AsyncRateLimitEnforcer": "chroma_async_rate_limit_enforcer_impl",
+ "chromadb.segment.SegmentManager": "chroma_segment_manager_impl",
+ "chromadb.segment.distributed.SegmentDirectory": "chroma_segment_directory_impl",
+ "chromadb.segment.distributed.MemberlistProvider": "chroma_memberlist_provider_impl",
+ "chromadb.telemetry.product.ProductTelemetryClient": "chroma_product_telemetry_impl",
+}
+
+DEFAULT_TENANT = "default_tenant"
+DEFAULT_DATABASE = "default_database"
+
+
+class APIVersion(str, Enum):
+ V1 = "/api/v1"
+ V2 = "/api/v2"
+
+
+# NOTE(hammadb) 1/13/2024 - This has to be in config.py instead of being localized to the module
+# that uses it because of a circular import issue. This is a temporary solution until we can
+# refactor the code to remove the circular import.
+class RoutingMode(Enum):
+ """
+ Routing mode for the segment directory
+
+ node - Assign based on the node name, used in production with multi-node settings with the assumption that
+ there is one query service pod per node. This is useful for when there is a disk based cache on the
+ node that we want to route to.
+
+ id - Assign based on the member id, used in development and testing environments where the node name is not
+ guaranteed to be unique. (I.e a local development kubernetes env). Or when there are multiple query service
+ pods per node.
+ """
+
+ NODE = "node"
+ ID = "id"
+
+
+class Settings(BaseSettings): # type: ignore
+ # ==============
+ # Generic config
+ # ==============
+
+ environment: str = ""
+
+ # Can be "chromadb.api.segment.SegmentAPI" or "chromadb.api.fastapi.FastAPI" or "chromadb.api.rust.RustBindingsAPI"
+ chroma_api_impl: str = "chromadb.api.rust.RustBindingsAPI"
+
+ chroma_server_nofile: Optional[int] = None
+
+ @field_validator("chroma_server_nofile", mode="before")
+ @classmethod
+ def empty_str_to_none(cls, v: Any) -> Optional[int]:
+ if isinstance(v, str) and v.strip() == "":
+ return None
+ return v
+
+ # the number of maximum threads to handle synchronous tasks in the FastAPI server
+ chroma_server_thread_pool_size: int = 40
+
+ # ==================
+ # Client-mode config
+ # ==================
+
+ tenant_id: str = "default"
+ topic_namespace: str = "default"
+
+ chroma_server_host: Optional[str] = None
+ chroma_server_headers: Optional[Dict[str, str]] = None
+ chroma_server_http_port: Optional[int] = None
+ chroma_server_ssl_enabled: Optional[bool] = False
+
+ chroma_server_ssl_verify: Optional[Union[bool, str]] = None
+ chroma_server_api_default_path: Optional[APIVersion] = APIVersion.V2
+ # eg ["http://localhost:8000"]
+ chroma_server_cors_allow_origins: List[str] = []
+
+ chroma_http_keepalive_secs: Optional[float] = 40.0
+ chroma_http_max_connections: Optional[int] = None
+ chroma_http_max_keepalive_connections: Optional[int] = None
+
+ # ==================
+ # Server config
+ # ==================
+
+ is_persistent: bool = False
+ persist_directory: str = "./chroma"
+
+ chroma_memory_limit_bytes: int = 0
+ chroma_segment_cache_policy: Optional[str] = None
+
+ allow_reset: bool = False
+
+ # ===========================
+ # {Client, Server} auth{n, z}
+ # ===========================
+
+ # The header to use for the token. Defaults to "Authorization".
+ chroma_auth_token_transport_header: Optional[str] = None
+
+ # ================
+ # Client auth{n,z}
+ # ================
+
+ # The provider for client auth. See chromadb/auth/__init__.py
+ chroma_client_auth_provider: Optional[str] = None
+ # If needed by the provider (e.g. BasicAuthClientProvider),
+ # the credentials to use.
+ chroma_client_auth_credentials: Optional[str] = None
+
+ # ================
+ # Server auth{n,z}
+ # ================
+
+ chroma_server_auth_ignore_paths: Dict[str, List[str]] = {
+ f"{APIVersion.V2}": ["GET"],
+ f"{APIVersion.V2}/heartbeat": ["GET"],
+ f"{APIVersion.V2}/version": ["GET"],
+ f"{APIVersion.V1}": ["GET"],
+ f"{APIVersion.V1}/heartbeat": ["GET"],
+ f"{APIVersion.V1}/version": ["GET"],
+ }
+ # Overwrite singleton tenant and database access from the auth provider
+ # if applicable. See chromadb/auth/utils/__init__.py's
+ # authenticate_and_authorize_or_raise method.
+ chroma_overwrite_singleton_tenant_database_access_from_auth: bool = False
+
+ # ============
+ # Server authn
+ # ============
+
+ chroma_server_authn_provider: Optional[str] = None
+ # Only one of the below may be specified.
+ chroma_server_authn_credentials: Optional[str] = None
+ chroma_server_authn_credentials_file: Optional[str] = None
+
+ # ============
+ # Server authz
+ # ============
+
+ chroma_server_authz_provider: Optional[str] = None
+ # Only one of the below may be specified.
+ chroma_server_authz_config: Optional[str] = None
+ chroma_server_authz_config_file: Optional[str] = None
+
+ # =========
+ # Telemetry
+ # =========
+
+ chroma_product_telemetry_impl: str = "chromadb.telemetry.product.posthog.Posthog"
+ # Required for backwards compatibility
+ chroma_telemetry_impl: str = chroma_product_telemetry_impl
+
+ anonymized_telemetry: bool = True
+
+ chroma_otel_collection_endpoint: Optional[str] = ""
+ chroma_otel_service_name: Optional[str] = "chromadb"
+ chroma_otel_collection_headers: Dict[str, str] = {}
+ chroma_otel_granularity: Optional[str] = None
+
+ # ==========
+ # Migrations
+ # ==========
+
+ migrations: Literal["none", "validate", "apply"] = "apply"
+ # you cannot change the hash_algorithm after migrations have already
+ # been applied once this is intended to be a first-time setup configuration
+ migrations_hash_algorithm: Literal["md5", "sha256"] = "md5"
+
+ # ==================
+ # Distributed Chroma
+ # ==================
+
+ chroma_segment_directory_impl: str = "chromadb.segment.impl.distributed.segment_directory.RendezvousHashSegmentDirectory"
+ chroma_segment_directory_routing_mode: RoutingMode = RoutingMode.ID
+
+ chroma_memberlist_provider_impl: str = "chromadb.segment.impl.distributed.segment_directory.CustomResourceMemberlistProvider"
+ worker_memberlist_name: str = "query-service-memberlist"
+
+ chroma_coordinator_host: str = "localhost"
+ # TODO this is the sysdb port. Should probably rename it.
+ chroma_server_grpc_port: Optional[int] = None
+ chroma_sysdb_impl: str = "chromadb.db.impl.sqlite.SqliteDB"
+
+ chroma_producer_impl: str = "chromadb.db.impl.sqlite.SqliteDB"
+ chroma_consumer_impl: str = "chromadb.db.impl.sqlite.SqliteDB"
+
+ chroma_segment_manager_impl: str = (
+ "chromadb.segment.impl.manager.local.LocalSegmentManager"
+ )
+ chroma_executor_impl: str = "chromadb.execution.executor.local.LocalExecutor"
+ chroma_query_replication_factor: int = 2
+
+ chroma_logservice_host: str = "localhost"
+ chroma_logservice_port: int = 50052
+
+ chroma_quota_provider_impl: Optional[str] = None
+ chroma_rate_limiting_provider_impl: Optional[str] = None
+
+ chroma_quota_enforcer_impl: str = (
+ "chromadb.quota.simple_quota_enforcer.SimpleQuotaEnforcer"
+ )
+
+ chroma_rate_limit_enforcer_impl: str = (
+ "chromadb.rate_limit.simple_rate_limit.SimpleRateLimitEnforcer"
+ )
+
+ chroma_async_rate_limit_enforcer_impl: str = (
+ "chromadb.rate_limit.simple_rate_limit.SimpleAsyncRateLimitEnforcer"
+ )
+
+ # ==========
+ # gRPC service config
+ # ==========
+ chroma_logservice_request_timeout_seconds: int = 3
+ chroma_sysdb_request_timeout_seconds: int = 3
+ chroma_query_request_timeout_seconds: int = 60
+
+ # ======
+ # Legacy
+ # ======
+
+ chroma_db_impl: Optional[str] = None
+ chroma_collection_assignment_policy_impl: str = (
+ "chromadb.ingest.impl.simple_policy.SimpleAssignmentPolicy"
+ )
+
+ # =======
+ # Methods
+ # =======
+
+ def require(self, key: str) -> Any:
+ """Return the value of a required config key, or raise an exception if it is not
+ set"""
+ val = self[key]
+ if val is None:
+ raise ValueError(f"Missing required config value '{key}'")
+ return val
+
+ def __getitem__(self, key: str) -> Any:
+ val = getattr(self, key)
+ # Error on legacy config values
+ if isinstance(val, str) and val in _legacy_config_values:
+ raise ValueError(LEGACY_ERROR)
+ return val
+
+ model_config = {"env_file": ".env", "env_file_encoding": "utf-8", "extra": "ignore"}
+
+
+T = TypeVar("T", bound="Component")
+
+
+class Component(ABC, EnforceOverrides):
+ _dependencies: Set["Component"]
+ _system: "System"
+ _running: bool
+
+ def __init__(self, system: "System"):
+ self._dependencies = set()
+ self._system = system
+ self._running = False
+
+ def require(self, type: Type[T]) -> T:
+ """Get a Component instance of the given type, and register as a dependency of
+ that instance."""
+ inst = self._system.instance(type)
+ self._dependencies.add(inst)
+ return inst
+
+ def dependencies(self) -> Set["Component"]:
+ """Return the full set of components this component depends on."""
+ return self._dependencies
+
+ def stop(self) -> None:
+ """Idempotently stop this component's execution and free all associated
+ resources."""
+ logger.debug(f"Stopping component {self.__class__.__name__}")
+ self._running = False
+
+ def start(self) -> None:
+ """Idempotently start this component's execution"""
+ logger.debug(f"Starting component {self.__class__.__name__}")
+ self._running = True
+
+ def reset_state(self) -> None:
+ """Reset this component's state to its initial blank state. Only intended to be
+ called from tests."""
+ logger.debug(f"Resetting component {self.__class__.__name__}")
+
+
+class System(Component):
+ settings: Settings
+ _instances: Dict[Type[Component], Component]
+
+ def __init__(self, settings: Settings):
+ if is_thin_client:
+ # The thin client is a system with only the API component
+ if settings["chroma_api_impl"] not in [
+ "chromadb.api.fastapi.FastAPI",
+ "chromadb.api.async_fastapi.AsyncFastAPI",
+ ]:
+ raise RuntimeError(
+ "Chroma is running in http-only client mode, and can only be run with 'chromadb.api.fastapi.FastAPI' or 'chromadb.api.async_fastapi.AsyncFastAPI' as the chroma_api_impl. \
+ see https://docs.trychroma.com/guides#using-the-python-http-only-client for more information."
+ )
+ # Validate settings don't contain any legacy config values
+ for key in _legacy_config_keys:
+ if settings[key] is not None:
+ raise ValueError(LEGACY_ERROR)
+
+ if (
+ settings["chroma_segment_cache_policy"] is not None
+ and settings["chroma_segment_cache_policy"] != "LRU"
+ ):
+ logger.error(
+ "Failed to set chroma_segment_cache_policy: Only LRU is available."
+ )
+ if settings["chroma_memory_limit_bytes"] == 0:
+ logger.error(
+ "Failed to set chroma_segment_cache_policy: chroma_memory_limit_bytes is require."
+ )
+
+ # Apply the nofile limit if set
+ if settings["chroma_server_nofile"] is not None:
+ if platform.system() != "Windows":
+ import resource
+
+ curr_soft, curr_hard = resource.getrlimit(resource.RLIMIT_NOFILE)
+ desired_soft = settings["chroma_server_nofile"]
+ # Validate
+ if desired_soft > curr_hard:
+ logging.warning(
+ f"chroma_server_nofile cannot be set to a value greater than the current hard limit of {curr_hard}. Keeping soft limit at {curr_soft}"
+ )
+ # Apply
+ elif desired_soft > curr_soft:
+ try:
+ resource.setrlimit(
+ resource.RLIMIT_NOFILE, (desired_soft, curr_hard)
+ )
+ logger.info(f"Set chroma_server_nofile to {desired_soft}")
+ except Exception as e:
+ logger.error(
+ f"Failed to set chroma_server_nofile to {desired_soft}: {e} nofile soft limit will remain at {curr_soft}"
+ )
+ # Don't apply if reducing the limit
+ elif desired_soft < curr_soft:
+ logger.warning(
+ f"chroma_server_nofile is set to {desired_soft}, but this is less than current soft limit of {curr_soft}. chroma_server_nofile will not be set."
+ )
+ else:
+ logger.warning(
+ "chroma_server_nofile is not supported on Windows. chroma_server_nofile will not be set."
+ )
+
+ self.settings = settings
+ self._instances = {}
+ super().__init__(self)
+
+ def instance(self, type: Type[T]) -> T:
+ """Return an instance of the component type specified. If the system is running,
+ the component will be started as well."""
+
+ if inspect.isabstract(type):
+ type_fqn = get_fqn(type)
+ if type_fqn not in _abstract_type_keys:
+ raise ValueError(f"Cannot instantiate abstract type: {type}")
+ key = _abstract_type_keys[type_fqn]
+ fqn = self.settings.require(key)
+ type = get_class(fqn, type)
+
+ if type not in self._instances:
+ impl = type(self)
+ self._instances[type] = impl
+ if self._running:
+ impl.start()
+
+ inst = self._instances[type]
+ return cast(T, inst)
+
+ def components(self) -> Iterable[Component]:
+ """Return the full set of all components and their dependencies in dependency
+ order."""
+ sorter: TopologicalSorter[Component] = TopologicalSorter()
+ for component in self._instances.values():
+ sorter.add(component, *component.dependencies())
+
+ return sorter.static_order()
+
+ @override
+ def start(self) -> None:
+ super().start()
+ for component in self.components():
+ component.start()
+
+ @override
+ def stop(self) -> None:
+ super().stop()
+ for component in reversed(list(self.components())):
+ component.stop()
+
+ @override
+ def reset_state(self) -> None:
+ """Reset the state of this system and all constituents in reverse dependency order"""
+ if not self.settings.allow_reset:
+ raise ValueError(
+ "Resetting is not allowed by this configuration (to enable it, set `allow_reset` to `True` in your Settings() or include `ALLOW_RESET=TRUE` in your environment variables)"
+ )
+ for component in reversed(list(self.components())):
+ component.reset_state()
+
+
+C = TypeVar("C")
+
+
+def get_class(fqn: str, type: Type[C]) -> Type[C]:
+ """Given a fully qualifed class name, import the module and return the class"""
+ module_name, class_name = fqn.rsplit(".", 1)
+ module = importlib.import_module(module_name)
+ cls = getattr(module, class_name)
+ return cast(Type[C], cls)
+
+
+def get_fqn(cls: Type[object]) -> str:
+ """Given a class, return its fully qualified name"""
+ return f"{cls.__module__}.{cls.__name__}"
diff --git a/python/user_packages/Python313/site-packages/chromadb/errors.py b/python/user_packages/Python313/site-packages/chromadb/errors.py
new file mode 100644
index 0000000000000000000000000000000000000000..b5c24d2ec2c6bf274ee8c8ee4f4ea1899b845e43
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/chromadb/errors.py
@@ -0,0 +1,194 @@
+from abc import abstractmethod
+from typing import Dict, Optional, Type
+from overrides import overrides, EnforceOverrides
+
+
+class ChromaError(Exception, EnforceOverrides):
+ trace_id: Optional[str] = None
+
+ def code(self) -> int:
+ """Return an appropriate HTTP response code for this error"""
+ return 400 # Bad Request
+
+ def message(self) -> str:
+ return ", ".join(self.args)
+
+ @classmethod
+ @abstractmethod
+ def name(cls) -> str:
+ """Return the error name"""
+ pass
+
+
+class InvalidDimensionException(ChromaError):
+ @classmethod
+ @overrides
+ def name(cls) -> str:
+ return "InvalidDimension"
+
+
+class IDAlreadyExistsError(ChromaError):
+ @overrides
+ def code(self) -> int:
+ return 409 # Conflict
+
+ @classmethod
+ @overrides
+ def name(cls) -> str:
+ return "IDAlreadyExists"
+
+
+class ChromaAuthError(ChromaError):
+ @overrides
+ def code(self) -> int:
+ return 403
+
+ @classmethod
+ @overrides
+ def name(cls) -> str:
+ return "AuthError"
+
+ @overrides
+ def message(self) -> str:
+ return "Forbidden"
+
+
+class DuplicateIDError(ChromaError):
+ @classmethod
+ @overrides
+ def name(cls) -> str:
+ return "DuplicateID"
+
+
+class InvalidArgumentError(ChromaError):
+ @overrides
+ def code(self) -> int:
+ return 400
+
+ @classmethod
+ @overrides
+ def name(cls) -> str:
+ return "InvalidArgument"
+
+
+class InvalidUUIDError(ChromaError):
+ @classmethod
+ @overrides
+ def name(cls) -> str:
+ return "InvalidUUID"
+
+
+class InvalidHTTPVersion(ChromaError):
+ @classmethod
+ @overrides
+ def name(cls) -> str:
+ return "InvalidHTTPVersion"
+
+
+class AuthorizationError(ChromaError):
+ @overrides
+ def code(self) -> int:
+ return 401
+
+ @classmethod
+ @overrides
+ def name(cls) -> str:
+ return "AuthorizationError"
+
+
+class NotFoundError(ChromaError):
+ @overrides
+ def code(self) -> int:
+ return 404
+
+ @classmethod
+ @overrides
+ def name(cls) -> str:
+ return "NotFoundError"
+
+
+class UniqueConstraintError(ChromaError):
+ @overrides
+ def code(self) -> int:
+ return 409
+
+ @classmethod
+ @overrides
+ def name(cls) -> str:
+ return "UniqueConstraintError"
+
+
+class BatchSizeExceededError(ChromaError):
+ @overrides
+ def code(self) -> int:
+ return 413
+
+ @classmethod
+ @overrides
+ def name(cls) -> str:
+ return "BatchSizeExceededError"
+
+
+class VersionMismatchError(ChromaError):
+ @overrides
+ def code(self) -> int:
+ return 500
+
+ @classmethod
+ @overrides
+ def name(cls) -> str:
+ return "VersionMismatchError"
+
+
+class InternalError(ChromaError):
+ @overrides
+ def code(self) -> int:
+ return 500
+
+ @classmethod
+ @overrides
+ def name(cls) -> str:
+ return "InternalError"
+
+
+class RateLimitError(ChromaError):
+ @overrides
+ def code(self) -> int:
+ return 429
+
+ @classmethod
+ @overrides
+ def name(cls) -> str:
+ return "RateLimitError"
+
+
+class QuotaError(ChromaError):
+ @overrides
+ def code(self) -> int:
+ return 400
+
+ @classmethod
+ @overrides
+ def name(cls) -> str:
+ return "QuotaError"
+
+
+error_types: Dict[str, Type[ChromaError]] = {
+ "InvalidDimension": InvalidDimensionException,
+ "InvalidArgumentError": InvalidArgumentError,
+ "IDAlreadyExists": IDAlreadyExistsError,
+ "DuplicateID": DuplicateIDError,
+ "InvalidUUID": InvalidUUIDError,
+ "InvalidHTTPVersion": InvalidHTTPVersion,
+ "AuthorizationError": AuthorizationError,
+ "NotFoundError": NotFoundError,
+ "BatchSizeExceededError": BatchSizeExceededError,
+ "VersionMismatchError": VersionMismatchError,
+ "RateLimitError": RateLimitError,
+ "AuthError": ChromaAuthError,
+ "UniqueConstraintError": UniqueConstraintError,
+ "QuotaError": QuotaError,
+ "InternalError": InternalError,
+ # Catch-all for any other errors
+ "ChromaError": ChromaError,
+}
diff --git a/python/user_packages/Python313/site-packages/chromadb/log_config.yml b/python/user_packages/Python313/site-packages/chromadb/log_config.yml
new file mode 100644
index 0000000000000000000000000000000000000000..cb448f366ccf775535d3b9d07815ff36d36dbadf
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/chromadb/log_config.yml
@@ -0,0 +1,37 @@
+version: 1
+disable_existing_loggers: False
+formatters:
+ default:
+ "()": uvicorn.logging.DefaultFormatter
+ format: '%(levelprefix)s [%(asctime)s] %(message)s'
+ use_colors: null
+ datefmt: '%d-%m-%Y %H:%M:%S'
+ access:
+ "()": uvicorn.logging.AccessFormatter
+ format: '%(levelprefix)s [%(asctime)s] %(client_addr)s - "%(request_line)s" %(status_code)s'
+ datefmt: '%d-%m-%Y %H:%M:%S'
+handlers:
+ default:
+ formatter: default
+ class: logging.StreamHandler
+ stream: ext://sys.stderr
+ access:
+ formatter: access
+ class: logging.StreamHandler
+ stream: ext://sys.stdout
+ console:
+ class: logging.StreamHandler
+ stream: ext://sys.stdout
+ formatter: default
+ file:
+ class : logging.handlers.RotatingFileHandler
+ filename: chroma.log
+ formatter: default
+loggers:
+ root:
+ level: WARN
+ handlers: [console, file]
+ chromadb:
+ level: DEBUG
+ uvicorn:
+ level: INFO
diff --git a/python/user_packages/Python313/site-packages/chromadb/py.typed b/python/user_packages/Python313/site-packages/chromadb/py.typed
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/python/user_packages/Python313/site-packages/chromadb/serde.py b/python/user_packages/Python313/site-packages/chromadb/serde.py
new file mode 100644
index 0000000000000000000000000000000000000000..57c38443ecd13d8cb2d428bb0c15f1b737f6694a
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/chromadb/serde.py
@@ -0,0 +1,51 @@
+from abc import abstractmethod
+from typing import Any, Dict, Generic, Protocol, TypeVar
+from typing_extensions import Self
+import json
+
+T = TypeVar("T", covariant=True)
+
+
+class JSONSerializable(Protocol[T]):
+ """A generic interface for objects that can be serialized to JSON"""
+
+ def to_json_str(self) -> str:
+ """Serializes the object to JSON"""
+ ...
+
+ @classmethod
+ def from_json_str(cls, json_str: str) -> Self:
+ """Deserializes the object from JSON"""
+ ...
+
+ def to_json(self) -> Dict[str, Any]:
+ """Serializes the object to a JSON compatible dictionary"""
+ ...
+
+ @classmethod
+ def from_json(cls, json_map: Dict[str, Any]) -> Self:
+ """Deserializes the object from JSON"""
+ ...
+
+
+class BaseModelJSONSerializable(Generic[T]):
+ """A mixin for BaseModels that allows a class to be serialized to JSON"""
+
+ def to_json_str(self) -> str:
+ """Serializes the object to JSON"""
+ return self.model_dump_json()
+
+ def to_json(self) -> Dict[str, Any]:
+ """Serializes the object to a JSON compatible dictionary"""
+ return json.loads(self.model_dump_json()) # type: ignore[no-any-return]
+
+ @abstractmethod
+ def model_dump_json(self) -> str:
+ """Abstract method that should be implemented to dump the model to JSON"""
+ pass
+
+ @classmethod
+ @abstractmethod
+ def from_json(cls, json_map: Dict[str, Any]) -> T:
+ """Deserializes the object from JSON"""
+ pass
diff --git a/python/user_packages/Python313/site-packages/chromadb/types.py b/python/user_packages/Python313/site-packages/chromadb/types.py
new file mode 100644
index 0000000000000000000000000000000000000000..c5b9920731c966dd4eaed41f9de3ad52bd28e214
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/chromadb/types.py
@@ -0,0 +1,342 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Any, Optional, Union, Sequence, Dict, Mapping, Generic
+
+from typing_extensions import Self
+
+from overrides import override
+from typing_extensions import TypedDict, TypeVar
+from uuid import UUID
+from enum import Enum
+from pydantic import BaseModel
+
+from chromadb.api.configuration import (
+ ConfigurationInternal,
+)
+from chromadb.api.types import Schema
+from chromadb.serde import BaseModelJSONSerializable
+from chromadb.api.collection_configuration import (
+ CollectionConfiguration,
+ collection_configuration_to_json,
+ load_collection_configuration_from_json,
+)
+
+from chromadb.base_types import (
+ Metadata,
+ UpdateMetadata,
+ Vector,
+ PyVector,
+ LiteralValue,
+ LogicalOperator,
+ WhereOperator,
+ OperatorExpression,
+ Where,
+ WhereDocumentOperator,
+ WhereDocument,
+ InclusionExclusionOperator,
+)
+
+# Namespaced Names are mechanically just strings, but we use this type to indicate that
+# the intent is for the value to be globally unique and semantically meaningful.
+NamespacedName = str
+
+
+class ScalarEncoding(Enum):
+ FLOAT32 = "FLOAT32"
+ INT32 = "INT32"
+
+
+class SegmentScope(Enum):
+ VECTOR = "VECTOR"
+ METADATA = "METADATA"
+ RECORD = "RECORD"
+
+
+C = TypeVar("C", bound=ConfigurationInternal)
+
+
+class Configurable(Generic[C], ABC):
+ """A mixin that allows a class to be configured with a configuration object"""
+
+ @abstractmethod
+ def get_configuration(self) -> C:
+ raise NotImplementedError()
+
+ @abstractmethod
+ def set_configuration(self, configuration: C) -> None:
+ raise NotImplementedError()
+
+
+class Collection(
+ BaseModel,
+ BaseModelJSONSerializable["Collection"],
+):
+ """A model of a collection used for transport, serialization, and storage"""
+
+ id: UUID
+ name: str
+ configuration_json: Dict[str, Any]
+ serialized_schema: Optional[Dict[str, Any]]
+ metadata: Optional[
+ Dict[str, Any]
+ ] # Dict[str, Any] needed by pydantic 1.x as it doesn't work well Union types and converts all types to str
+ dimension: Optional[int]
+ tenant: str
+ database: str
+ # The version and log position is only used in the distributed version of chroma
+ # in single-node chroma, this field is always 0
+ version: int
+ log_position: int
+
+ def __init__(
+ self,
+ id: UUID,
+ name: str,
+ configuration_json: Dict[str, Any],
+ serialized_schema: Optional[Dict[str, Any]],
+ metadata: Optional[Metadata],
+ dimension: Optional[int],
+ tenant: str,
+ database: str,
+ version: int = 0,
+ log_position: int = 0,
+ ):
+ super().__init__(
+ id=id,
+ name=name,
+ serialized_schema=serialized_schema,
+ metadata=metadata,
+ configuration_json=configuration_json,
+ dimension=dimension,
+ tenant=tenant,
+ database=database,
+ version=version,
+ log_position=log_position,
+ )
+
+ # TODO: This throws away type information.
+ def __getitem__(self, key: str) -> Optional[Any]:
+ """Allows the collection to be treated as a dictionary"""
+ if key == "configuration":
+ return self.get_configuration()
+ # For the other model attributes we allow the user to access them directly
+ if key in self.get_model_fields():
+ return getattr(self, key)
+ return None
+
+ # TODO: This doesn't check types.
+ def __setitem__(self, key: str, value: Any) -> None:
+ """Allows the collection to be treated as a dictionary"""
+ # For the model attributes we allow the user to access them directly
+ if key == "configuration":
+ self.set_configuration(value)
+ if key in self.get_model_fields():
+ setattr(self, key, value)
+ else:
+ raise KeyError(
+ f"No such key: {key}, valid keys are: {self.get_model_fields()}"
+ )
+
+ def __eq__(self, __value: object) -> bool:
+ # Check that all the model fields are equal
+ if not isinstance(__value, Collection):
+ return False
+ for field in self.get_model_fields():
+ if getattr(self, field) != getattr(__value, field):
+ return False
+ return True
+
+ def get_configuration(self) -> CollectionConfiguration:
+ """Returns the configuration of the collection"""
+ try:
+ return load_collection_configuration_from_json(self.configuration_json)
+ except Exception as e:
+ raise ValueError(
+ f"Could not deserialize configuration_json: {e}",
+ )
+
+ def get_serialized_schema(self) -> Optional[Dict[str, Any]]:
+ """Returns the serialized_schema of the collection"""
+ return self.serialized_schema
+
+ def set_configuration(self, configuration: CollectionConfiguration) -> None:
+ """Sets the configuration of the collection"""
+ self.configuration_json = collection_configuration_to_json(configuration)
+
+ def set_serialized_schema(self, serialized_schema: Dict[str, Any]) -> None:
+ """Sets the serialized_schema of the collection"""
+ self.serialized_schema = serialized_schema
+
+ def get_model_fields(self) -> Dict[Any, Any]:
+ """Used for backward compatibility with Pydantic 1.x"""
+ try:
+ return type(self).model_fields # pydantic 2.x, pydantic 3.x
+ except AttributeError:
+ return self.__fields__ # pydantic 1.x
+
+ def pretty_schema(self) -> str:
+ """Returns a pretty-printed version of the serialized schema."""
+ if self.serialized_schema is None:
+ return "No schema"
+ import json
+ return json.dumps(self.serialized_schema, indent=2)
+
+ @classmethod
+ @override
+ def from_json(cls, json_map: Dict[str, Any]) -> Self:
+ """Deserializes a Collection object from JSON"""
+ return cls(
+ id=json_map["id"],
+ name=json_map["name"],
+ configuration_json=json_map.get("configuration_json", None),
+ serialized_schema=json_map.get("schema", None),
+ metadata=json_map.get("metadata", None),
+ dimension=json_map.get("dimension", None),
+ tenant=json_map["tenant"],
+ database=json_map["database"],
+ version=json_map.get("version", 0),
+ log_position=json_map.get("log_position", 0),
+ )
+
+
+class Database(TypedDict):
+ id: UUID
+ name: str
+ tenant: str
+
+
+class Tenant(TypedDict):
+ name: str
+
+
+class Segment(TypedDict):
+ id: UUID
+ type: NamespacedName
+ scope: SegmentScope
+ collection: UUID
+ metadata: Optional[Metadata]
+ file_paths: Mapping[str, Sequence[str]]
+
+
+class CollectionAndSegments(TypedDict):
+ collection: Collection
+ segments: Sequence[Segment]
+
+
+# SeqID can be one of three types of value in our current and future plans:
+# 1. A Pulsar MessageID encoded as a 192-bit integer - This is no longer used as we removed pulsar
+# 2. A Pulsar MessageIndex (a 64-bit integer) - This is no longer used as we removed pulsar
+# 3. A SQL RowID (a 64-bit integer) - This is used by both sqlite and the new log-service
+
+# All three of these types can be expressed as a Python int, so that is the type we
+# use in the internal Python API. However, care should be taken that the larger 192-bit
+# values are stored correctly when persisting to DBs.
+SeqId = int
+
+
+class Operation(Enum):
+ ADD = "ADD"
+ UPDATE = "UPDATE"
+ UPSERT = "UPSERT"
+ DELETE = "DELETE"
+
+
+class VectorEmbeddingRecord(TypedDict):
+ id: str
+ embedding: Vector
+
+
+class MetadataEmbeddingRecord(TypedDict):
+ id: str
+ metadata: Optional[Metadata]
+
+
+class OperationRecord(TypedDict):
+ id: str
+ embedding: Optional[Vector]
+ encoding: Optional[ScalarEncoding]
+ metadata: Optional[UpdateMetadata]
+ operation: Operation
+
+
+class LogRecord(TypedDict):
+ log_offset: int
+ record: OperationRecord
+
+
+class RequestVersionContext(TypedDict):
+ """The version and log position of the collection at the time of the request
+
+ This is used to ensure that the request is processed against the correct version of the collection,
+ as well as that the pulled logs are consistent with the start offset of the compacted collection.
+
+ For example, if the FE first queries the metadata segment and then queries the vector segment, the version
+ and log position of the collection may have changed between the two queries. The FE can use this context to
+ ensure that the second query is processed against the correct version of the collection.
+
+ If a query is shared between multiple segments, the version context should be passed to the query for each segment.
+ This ensures that the query is processed against the correct version of the collection.
+
+ Only used in the impls of distributed Chroma.
+ """
+
+ collection_version: int
+ log_position: int
+
+
+class VectorQuery(TypedDict):
+ """A KNN/ANN query"""
+
+ vectors: Sequence[Vector]
+ k: int
+ allowed_ids: Optional[Sequence[str]]
+ include_embeddings: bool
+ options: Optional[Dict[str, Union[str, int, float, bool]]]
+ request_version_context: RequestVersionContext
+
+
+class VectorQueryResult(TypedDict):
+ """A KNN/ANN query result"""
+
+ id: str
+ distance: float
+ embedding: Optional[Vector]
+
+
+class Unspecified:
+ """A sentinel value used to indicate that a value should not be updated"""
+
+ _instance: Optional["Unspecified"] = None
+
+ def __new__(cls) -> "Unspecified":
+ if cls._instance is None:
+ cls._instance = super(Unspecified, cls).__new__(cls)
+
+ return cls._instance
+
+
+T = TypeVar("T")
+OptionalArgument = Union[T, Unspecified]
+
+
+@dataclass
+class CloudClientArg:
+ name: str
+ env_var: str
+ value: Optional[str] = None
+
+
+__all__ = [
+ "Metadata",
+ "UpdateMetadata",
+ "Vector",
+ "PyVector",
+ "LiteralValue",
+ "LogicalOperator",
+ "WhereOperator",
+ "OperatorExpression",
+ "Where",
+ "WhereDocumentOperator",
+ "WhereDocument",
+ "InclusionExclusionOperator",
+]
diff --git a/python/user_packages/Python313/site-packages/chromadb_rust_bindings/__init__.py b/python/user_packages/Python313/site-packages/chromadb_rust_bindings/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..60bb85ff91c206a5670e1aaf123269f86c06f1ec
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/chromadb_rust_bindings/__init__.py
@@ -0,0 +1,5 @@
+from .chromadb_rust_bindings import *
+
+__doc__ = chromadb_rust_bindings.__doc__
+if hasattr(chromadb_rust_bindings, "__all__"):
+ __all__ = chromadb_rust_bindings.__all__
\ No newline at end of file
diff --git a/python/user_packages/Python313/site-packages/click-8.3.3.dist-info/INSTALLER b/python/user_packages/Python313/site-packages/click-8.3.3.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/click-8.3.3.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/python/user_packages/Python313/site-packages/click-8.3.3.dist-info/METADATA b/python/user_packages/Python313/site-packages/click-8.3.3.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..30fbba6dd73ef6f9c454ae08f409d0306eeadb9d
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/click-8.3.3.dist-info/METADATA
@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: click
+Version: 8.3.3
+Summary: Composable command line interface toolkit
+Maintainer-email: Pallets
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-Expression: BSD-3-Clause
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Typing :: Typed
+License-File: LICENSE.txt
+Requires-Dist: colorama; platform_system == 'Windows'
+Project-URL: Changes, https://click.palletsprojects.com/page/changes/
+Project-URL: Chat, https://discord.gg/pallets
+Project-URL: Documentation, https://click.palletsprojects.com/
+Project-URL: Donate, https://palletsprojects.com/donate
+Project-URL: Source, https://github.com/pallets/click/
+
+
+
+
+ 
+
+
+ 
+
+
+
+ 
+ 
+
+ 
+ 
+ 
+
+
+ 
+
+
+ 
+
+
+ 
+
+
+## Installation
+
+```bash
+pip install annotated-doc
+```
+
+Or with `uv`:
+
+```Python
+uv add annotated-doc
+```
+
+## Usage
+
+Import `Doc` and pass a single literal string with the documentation for the specific parameter, class attribute, return type, or variable.
+
+For example, to document a parameter `name` in a function `hi` you could do:
+
+```Python
+from typing import Annotated
+
+from annotated_doc import Doc
+
+def hi(name: Annotated[str, Doc("Who to say hi to")]) -> None:
+ print(f"Hi, {name}!")
+```
+
+You can also use it to document class attributes:
+
+```Python
+from typing import Annotated
+
+from annotated_doc import Doc
+
+class User:
+ name: Annotated[str, Doc("The user's name")]
+ age: Annotated[int, Doc("The user's age")]
+```
+
+The same way, you could document return types and variables, or anything that could have a type annotation with `Annotated`.
+
+## Who Uses This
+
+`annotated-doc` was made for:
+
+* [FastAPI](https://fastapi.tiangolo.com/)
+* [Typer](https://typer.tiangolo.com/)
+* [SQLModel](https://sqlmodel.tiangolo.com/)
+* [Asyncer](https://asyncer.tiangolo.com/)
+
+`annotated-doc` is supported by [griffe-typingdoc](https://github.com/mkdocstrings/griffe-typingdoc), which powers reference documentation like the one in the [FastAPI Reference](https://fastapi.tiangolo.com/reference/).
+
+## Reasons not to use `annotated-doc`
+
+You are already comfortable with one of the existing docstring formats, like:
+
+* Sphinx
+* numpydoc
+* Google
+* Keras
+
+Your team is already comfortable using them.
+
+You prefer having the documentation about parameters all together in a docstring, separated from the code defining them.
+
+You care about a specific set of users, using one specific editor, and that editor already has support for the specific docstring format you use.
+
+## Reasons to use `annotated-doc`
+
+* No micro-syntax to learn for newcomers, it’s **just Python** syntax.
+* **Editing** would be already fully supported by default by any editor (current or future) supporting Python syntax, including syntax errors, syntax highlighting, etc.
+* **Rendering** would be relatively straightforward to implement by static tools (tools that don't need runtime execution), as the information can be extracted from the AST they normally already create.
+* **Deduplication of information**: the name of a parameter would be defined in a single place, not duplicated inside of a docstring.
+* **Elimination** of the possibility of having **inconsistencies** when removing a parameter or class variable and **forgetting to remove** its documentation.
+* **Minimization** of the probability of adding a new parameter or class variable and **forgetting to add its documentation**.
+* **Elimination** of the possibility of having **inconsistencies** between the **name** of a parameter in the **signature** and the name in the docstring when it is renamed.
+* **Access** to the documentation string for each symbol at **runtime**, including existing (older) Python versions.
+* A more formalized way to document other symbols, like type aliases, that could use Annotated.
+* **Support** for apps using FastAPI, Typer and others.
+* **AI Accessibility**: AI tools will have an easier way understanding each parameter as the distance from documentation to parameter is much closer.
+
+## History
+
+I ([@tiangolo](https://github.com/tiangolo)) originally wanted for this to be part of the Python standard library (in [PEP 727](https://peps.python.org/pep-0727/)), but the proposal was withdrawn as there was a fair amount of negative feedback and opposition.
+
+The conclusion was that this was better done as an external effort, in a third-party library.
+
+So, here it is, with a simpler approach, as a third-party library, in a way that can be used by others, starting with FastAPI and friends.
+
+## License
+
+This project is licensed under the terms of the MIT license.
diff --git a/python/user_packages/Python313/site-packages/annotated_doc-0.0.4.dist-info/RECORD b/python/user_packages/Python313/site-packages/annotated_doc-0.0.4.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..3cfa26bd35a99e6126565fa2184c25c967c1e8be
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/annotated_doc-0.0.4.dist-info/RECORD
@@ -0,0 +1,11 @@
+annotated_doc-0.0.4.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+annotated_doc-0.0.4.dist-info/METADATA,sha256=Irm5KJua33dY2qKKAjJ-OhKaVBVIfwFGej_dSe3Z1TU,6566
+annotated_doc-0.0.4.dist-info/RECORD,,
+annotated_doc-0.0.4.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
+annotated_doc-0.0.4.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+annotated_doc-0.0.4.dist-info/licenses/LICENSE,sha256=__Fwd5pqy_ZavbQFwIfxzuF4ZpHkqWpANFF-SlBKDN8,1086
+annotated_doc/__init__.py,sha256=VuyxxUe80kfEyWnOrCx_Bk8hybo3aKo6RYBlkBBYW8k,52
+annotated_doc/__pycache__/__init__.cpython-313.pyc,,
+annotated_doc/__pycache__/main.cpython-313.pyc,,
+annotated_doc/main.py,sha256=5Zfvxv80SwwLqpRW73AZyZyiM4bWma9QWRbp_cgD20s,1075
+annotated_doc/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
diff --git a/python/user_packages/Python313/site-packages/annotated_doc-0.0.4.dist-info/WHEEL b/python/user_packages/Python313/site-packages/annotated_doc-0.0.4.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..045c8acdea31cbca5be986e915f784c1aafc720f
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/annotated_doc-0.0.4.dist-info/WHEEL
@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: pdm-backend (2.4.5)
+Root-Is-Purelib: true
+Tag: py3-none-any
diff --git a/python/user_packages/Python313/site-packages/annotated_doc-0.0.4.dist-info/entry_points.txt b/python/user_packages/Python313/site-packages/annotated_doc-0.0.4.dist-info/entry_points.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c3ad4726d437022e5c606a4206ffb6007347a008
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/annotated_doc-0.0.4.dist-info/entry_points.txt
@@ -0,0 +1,4 @@
+[console_scripts]
+
+[gui_scripts]
+
diff --git a/python/user_packages/Python313/site-packages/annotated_doc/__init__.py b/python/user_packages/Python313/site-packages/annotated_doc/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a0152a7d12abc2db37fb26e764a61e0c894a43f3
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/annotated_doc/__init__.py
@@ -0,0 +1,3 @@
+from .main import Doc as Doc
+
+__version__ = "0.0.4"
diff --git a/python/user_packages/Python313/site-packages/annotated_doc/main.py b/python/user_packages/Python313/site-packages/annotated_doc/main.py
new file mode 100644
index 0000000000000000000000000000000000000000..7063c59e4500a1d02bfc9b41887f9e95f8163507
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/annotated_doc/main.py
@@ -0,0 +1,36 @@
+class Doc:
+ """Define the documentation of a type annotation using `Annotated`, to be
+ used in class attributes, function and method parameters, return values,
+ and variables.
+
+ The value should be a positional-only string literal to allow static tools
+ like editors and documentation generators to use it.
+
+ This complements docstrings.
+
+ The string value passed is available in the attribute `documentation`.
+
+ Example:
+
+ ```Python
+ from typing import Annotated
+ from annotated_doc import Doc
+
+ def hi(name: Annotated[str, Doc("Who to say hi to")]) -> None:
+ print(f"Hi, {name}!")
+ ```
+ """
+
+ def __init__(self, documentation: str, /) -> None:
+ self.documentation = documentation
+
+ def __repr__(self) -> str:
+ return f"Doc({self.documentation!r})"
+
+ def __hash__(self) -> int:
+ return hash(self.documentation)
+
+ def __eq__(self, other: object) -> bool:
+ if not isinstance(other, Doc):
+ return NotImplemented
+ return self.documentation == other.documentation
diff --git a/python/user_packages/Python313/site-packages/annotated_doc/py.typed b/python/user_packages/Python313/site-packages/annotated_doc/py.typed
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/python/user_packages/Python313/site-packages/annotated_types-0.7.0.dist-info/INSTALLER b/python/user_packages/Python313/site-packages/annotated_types-0.7.0.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/annotated_types-0.7.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/python/user_packages/Python313/site-packages/annotated_types-0.7.0.dist-info/METADATA b/python/user_packages/Python313/site-packages/annotated_types-0.7.0.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..3ac05cfd1077ba5664e98ecd1342f7c54360b936
--- /dev/null
+++ b/python/user_packages/Python313/site-packages/annotated_types-0.7.0.dist-info/METADATA
@@ -0,0 +1,295 @@
+Metadata-Version: 2.3
+Name: annotated-types
+Version: 0.7.0
+Summary: Reusable constraint types to use with typing.Annotated
+Project-URL: Homepage, https://github.com/annotated-types/annotated-types
+Project-URL: Source, https://github.com/annotated-types/annotated-types
+Project-URL: Changelog, https://github.com/annotated-types/annotated-types/releases
+Author-email: Adrian Garcia Badaracco <1755071+adriangb@users.noreply.github.com>, Samuel Colvin 
+
+
+
+
+
+
+
+
+
+
+
+ 
+