Init-Commit v3-postupdates

.gitignore

@@ -0,0 +1,65 @@
+# Ignore environment variable files
+.env
+
+# Ignore Python bytecode
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Ignore virtual environment directories
+venv/
+env/
+.venv/
+.env/
+Include/
+Lib/
+Library/
+Scripts/
+Share/
+
+# Ignore Jupyter Notebook checkpoints
+.ipynb_checkpoints/
+
+# Ignore macOS system files
+.DS_Store
+
+# Ignore temporary files created by editors
+*.swp
+*.swo
+*~
+*.bak
+
+# Ignore logs
+*.log
+
+# Ignore coverage reports
+htmlcov/
+.coverage
+.coverage.*
+
+# Ignore mypy cache
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Ignore Pytest cache
+.pytest_cache/
+
+# Ignore temporary files
+*.tmp
+*.temp
+
+# Ignore compiled code
+*.so
+*.dylib
+*.dll
+
+# Ignore package directories
+node_modules/
+build/
+dist/
+*.egg-info/
+
+# Ignore Hugging Face Spaces outputs
+output/
+runs/

ILYA/Lib/site-packages/GitPython-3.1.43.dist-info/AUTHORS

@@ -1,58 +0,0 @@
-GitPython was originally written by Michael Trier.
-GitPython 0.2 was partially (re)written by Sebastian Thiel, based on 0.1.6 and git-dulwich.
-
-Contributors are:
-
--Michael Trier <mtrier _at_ gmail.com>
--Alan Briolat
--Florian Apolloner <florian _at_ apolloner.eu>
--David Aguilar <davvid _at_ gmail.com>
--Jelmer Vernooij <jelmer _at_ samba.org>
--Steve Frécinaux <code _at_ istique.net>
--Kai Lautaportti <kai _at_ lautaportti.fi>
--Paul Sowden <paul _at_ idontsmoke.co.uk>
--Sebastian Thiel <byronimo _at_ gmail.com>
--Jonathan Chu <jonathan.chu _at_ me.com>
--Vincent Driessen <me _at_ nvie.com>
--Phil Elson <pelson _dot_ pub _at_ gmail.com>
--Bernard `Guyzmo` Pratz <[email protected]>
--Timothy B. Hartman <tbhartman _at_ gmail.com>
--Konstantin Popov <konstantin.popov.89 _at_ yandex.ru>
--Peter Jones <pjones _at_ redhat.com>
--Anson Mansfield <anson.mansfield _at_ gmail.com>
--Ken Odegard <ken.odegard _at_ gmail.com>
--Alexis Horgix Chotard
--Piotr Babij <piotr.babij _at_ gmail.com>
--Mikuláš Poul <mikulaspoul _at_ gmail.com>
--Charles Bouchard-Légaré <cblegare.atl _at_ ntis.ca>
--Yaroslav Halchenko <debian _at_ onerussian.com>
--Tim Swast <swast _at_ google.com>
--William Luc Ritchie
--David Host <hostdm _at_ outlook.com>
--A. Jesse Jiryu Davis <jesse _at_ emptysquare.net>
--Steven Whitman <ninloot _at_ gmail.com>
--Stefan Stancu <stefan.stancu _at_ gmail.com>
--César Izurieta <cesar _at_ caih.org>
--Arthur Milchior <arthur _at_ milchior.fr>
--Anil Khatri <anil.soccer.khatri _at_ gmail.com>
--JJ Graham <thetwoj _at_ gmail.com>
--Ben Thayer <ben _at_ benthayer.com>
--Dries Kennes <admin _at_ dries007.net>
--Pratik Anurag <panurag247365 _at_ gmail.com>
--Harmon <harmon.public _at_ gmail.com>
--Liam Beguin <liambeguin _at_ gmail.com>
--Ram Rachum <ram _at_ rachum.com>
--Alba Mendez <me _at_ alba.sh>
--Robert Westman <robert _at_ byteflux.io>
--Hugo van Kemenade
--Hiroki Tokunaga <tokusan441 _at_ gmail.com>
--Julien Mauroy <pro.julien.mauroy _at_ gmail.com>
--Patrick Gerard
--Luke Twist <[email protected]>
--Joseph Hale <me _at_ jhale.dev>
--Santos Gallegos <stsewd _at_ proton.me>
--Wenhan Zhu <wzhu.cosmos _at_ gmail.com>
--Eliah Kagan <eliah.kagan _at_ gmail.com>
--Ethan Lin <et.repositories _at_ gmail.com>
-
-Portions derived from other open source works and are clearly marked.

ILYA/Lib/site-packages/GitPython-3.1.43.dist-info/INSTALLER

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

ILYA/Lib/site-packages/GitPython-3.1.43.dist-info/LICENSE

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

ILYA/Lib/site-packages/GitPython-3.1.43.dist-info/METADATA

@@ -1,297 +0,0 @@
-Metadata-Version: 2.1
-Name: GitPython
-Version: 3.1.43
-Summary: GitPython is a Python library used to interact with Git repositories
-Home-page: https://github.com/gitpython-developers/GitPython
-Author: Sebastian Thiel, Michael Trier
-Author-email: [email protected], [email protected]
-License: BSD-3-Clause
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Environment :: Console
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Operating System :: OS Independent
-Classifier: Operating System :: POSIX
-Classifier: Operating System :: Microsoft :: Windows
-Classifier: Operating System :: MacOS :: MacOS X
-Classifier: Typing :: Typed
-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
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-License-File: AUTHORS
-Requires-Dist: gitdb <5,>=4.0.1
-Requires-Dist: typing-extensions >=3.7.4.3 ; python_version < "3.8"
-Provides-Extra: doc
-Requires-Dist: sphinx ==4.3.2 ; extra == 'doc'
-Requires-Dist: sphinx-rtd-theme ; extra == 'doc'
-Requires-Dist: sphinxcontrib-applehelp <=1.0.4,>=1.0.2 ; extra == 'doc'
-Requires-Dist: sphinxcontrib-devhelp ==1.0.2 ; extra == 'doc'
-Requires-Dist: sphinxcontrib-htmlhelp <=2.0.1,>=2.0.0 ; extra == 'doc'
-Requires-Dist: sphinxcontrib-qthelp ==1.0.3 ; extra == 'doc'
-Requires-Dist: sphinxcontrib-serializinghtml ==1.1.5 ; extra == 'doc'
-Requires-Dist: sphinx-autodoc-typehints ; extra == 'doc'
-Provides-Extra: test
-Requires-Dist: coverage[toml] ; extra == 'test'
-Requires-Dist: ddt !=1.4.3,>=1.1.1 ; extra == 'test'
-Requires-Dist: mypy ; extra == 'test'
-Requires-Dist: pre-commit ; extra == 'test'
-Requires-Dist: pytest >=7.3.1 ; extra == 'test'
-Requires-Dist: pytest-cov ; extra == 'test'
-Requires-Dist: pytest-instafail ; extra == 'test'
-Requires-Dist: pytest-mock ; extra == 'test'
-Requires-Dist: pytest-sugar ; extra == 'test'
-Requires-Dist: typing-extensions ; (python_version < "3.11") and extra == 'test'
-Requires-Dist: mock ; (python_version < "3.8") and extra == 'test'
-
-![Python package](https://github.com/gitpython-developers/GitPython/workflows/Python%20package/badge.svg)
-[![Documentation Status](https://readthedocs.org/projects/gitpython/badge/?version=stable)](https://readthedocs.org/projects/gitpython/?badge=stable)
-[![Packaging status](https://repology.org/badge/tiny-repos/python:gitpython.svg)](https://repology.org/metapackage/python:gitpython/versions)
-
-## [Gitoxide](https://github.com/Byron/gitoxide): A peek into the future…
-
-I started working on GitPython in 2009, back in the days when Python was 'my thing' and I had great plans with it.
-Of course, back in the days, I didn't really know what I was doing and this shows in many places. Somewhat similar to
-Python this happens to be 'good enough', but at the same time is deeply flawed and broken beyond repair.
-
-By now, GitPython is widely used and I am sure there is a good reason for that, it's something to be proud of and happy about.
-The community is maintaining the software and is keeping it relevant for which I am absolutely grateful. For the time to come I am happy to continue maintaining GitPython, remaining hopeful that one day it won't be needed anymore.
-
-More than 15 years after my first meeting with 'git' I am still in excited about it, and am happy to finally have the tools and
-probably the skills to scratch that itch of mine: implement `git` in a way that makes tool creation a piece of cake for most.
-
-If you like the idea and want to learn more, please head over to [gitoxide](https://github.com/Byron/gitoxide), an
-implementation of 'git' in [Rust](https://www.rust-lang.org).
-
-*(Please note that `gitoxide` is not currently available for use in Python, and that Rust is required.)*
-
-## GitPython
-
-GitPython is a python library used to interact with git repositories, high-level like git-porcelain,
-or low-level like git-plumbing.
-
-It provides abstractions of git objects for easy access of repository data often backed by calling the `git`
-command-line program.
-
-### DEVELOPMENT STATUS
-
-This project is in **maintenance mode**, which means that
-
-- …there will be no feature development, unless these are contributed
-- …there will be no bug fixes, unless they are relevant to the safety of users, or contributed
-- …issues will be responded to with waiting times of up to a month
-
-The project is open to contributions of all kinds, as well as new maintainers.
-
-### REQUIREMENTS
-
-GitPython needs the `git` executable to be installed on the system and available in your
-`PATH` for most operations. If it is not in your `PATH`, you can help GitPython find it
-by setting the `GIT_PYTHON_GIT_EXECUTABLE=<path/to/git>` environment variable.
-
-- Git (1.7.x or newer)
-- Python >= 3.7
-
-The list of dependencies are listed in `./requirements.txt` and `./test-requirements.txt`.
-The installer takes care of installing them for you.
-
-### INSTALL
-
-GitPython and its required package dependencies can be installed in any of the following ways, all of which should typically be done in a [virtual environment](https://docs.python.org/3/tutorial/venv.html).
-
-#### From PyPI
-
-To obtain and install a copy [from PyPI](https://pypi.org/project/GitPython/), run:
-
-```sh
-pip install GitPython
-```
-
-(A distribution package can also be downloaded for manual installation at [the PyPI page](https://pypi.org/project/GitPython/).)
-
-#### From downloaded source code
-
-If you have downloaded the source code, run this from inside the unpacked `GitPython` directory:
-
-```sh
-pip install .
-```
-
-#### By cloning the source code repository
-
-To clone the [the GitHub repository](https://github.com/gitpython-developers/GitPython) from source to work on the code, you can do it like so:
-
-```sh
-git clone https://github.com/gitpython-developers/GitPython
-cd GitPython
-./init-tests-after-clone.sh
-```
-
-On Windows, `./init-tests-after-clone.sh` can be run in a Git Bash shell.
-
-If you are cloning [your own fork](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/working-with-forks/about-forks), then replace the above `git clone` command with one that gives the URL of your fork. Or use this [`gh`](https://cli.github.com/) command (assuming you have `gh` and your fork is called `GitPython`):
-
-```sh
-gh repo clone GitPython
-```
-
-Having cloned the repo, create and activate your [virtual environment](https://docs.python.org/3/tutorial/venv.html).
-
-Then make an [editable install](https://pip.pypa.io/en/stable/topics/local-project-installs/#editable-installs):
-
-```sh
-pip install -e ".[test]"
-```
-
-In the less common case that you do not want to install test dependencies, `pip install -e .` can be used instead.
-
-#### With editable *dependencies* (not preferred, and rarely needed)
-
-In rare cases, you may want to work on GitPython and one or both of its [gitdb](https://github.com/gitpython-developers/gitdb) and [smmap](https://github.com/gitpython-developers/smmap) dependencies at the same time, with changes in your local working copy of gitdb or smmap immediatley reflected in the behavior of your local working copy of GitPython. This can be done by making editable installations of those dependencies in the same virtual environment where you install GitPython.
-
-If you want to do that *and* you want the versions in GitPython's git submodules to be used, then pass `-e git/ext/gitdb` and/or `-e git/ext/gitdb/gitdb/ext/smmap` to `pip install`. This can be done in any order, and in separate `pip install` commands or the same one, so long as `-e` appears before *each* path. For example, you can install GitPython, gitdb, and smmap editably in the currently active virtual environment this way:
-
-```sh
-pip install -e ".[test]" -e git/ext/gitdb -e git/ext/gitdb/gitdb/ext/smmap
-```
-
-The submodules must have been cloned for that to work, but that will already be the case if you have run `./init-tests-after-clone.sh`. You can use `pip list` to check which packages are installed editably and which are installed normally.
-
-To reiterate, this approach should only rarely be used. For most development it is preferable to allow the gitdb and smmap dependencices to be retrieved automatically from PyPI in their latest stable packaged versions.
-
-### Limitations
-
-#### Leakage of System Resources
-
-GitPython is not suited for long-running processes (like daemons) as it tends to
-leak system resources. It was written in a time where destructors (as implemented
-in the `__del__` method) still ran deterministically.
-
-In case you still want to use it in such a context, you will want to search the
-codebase for `__del__` implementations and call these yourself when you see fit.
-
-Another way assure proper cleanup of resources is to factor out GitPython into a
-separate process which can be dropped periodically.
-
-#### Windows support
-
-See [Issue #525](https://github.com/gitpython-developers/GitPython/issues/525).
-
-### RUNNING TESTS
-
-_Important_: Right after cloning this repository, please be sure to have executed
-the `./init-tests-after-clone.sh` script in the repository root. Otherwise
-you will encounter test failures.
-
-#### Install test dependencies
-
-Ensure testing libraries are installed. This is taken care of already if you installed with:
-
-```sh
-pip install -e ".[test]"
-```
-
-If you had installed with a command like `pip install -e .` instead, you can still run
-the above command to add the testing dependencies.
-
-#### Test commands
-
-To test, run:
-
-```sh
-pytest
-```
-
-To lint, and apply some linting fixes as well as automatic code formatting, run:
-
-```sh
-pre-commit run --all-files
-```
-
-This includes the linting and autoformatting done by Ruff, as well as some other checks.
-
-To typecheck, run:
-
-```sh
-mypy
-```
-
-#### CI (and tox)
-
-Style and formatting checks, and running tests on all the different supported Python versions, will be performed:
-
-- Upon submitting a pull request.
-- On each push, *if* you have a fork with GitHub Actions enabled.
-- Locally, if you run [`tox`](https://tox.wiki/) (this skips any Python versions you don't have installed).
-
-#### Configuration files
-
-Specific tools are all configured in the `./pyproject.toml` file:
-
-- `pytest` (test runner)
-- `coverage.py` (code coverage)
-- `ruff` (linter and formatter)
-- `mypy` (type checker)
-
-Orchestration tools:
-
-- Configuration for `pre-commit` is in the `./.pre-commit-config.yaml` file.
-- Configuration for `tox` is in `./tox.ini`.
-- Configuration for GitHub Actions (CI) is in files inside `./.github/workflows/`.
-
-### Contributions
-
-Please have a look at the [contributions file][contributing].
-
-### INFRASTRUCTURE
-
-- [User Documentation](http://gitpython.readthedocs.org)
-- [Questions and Answers](http://stackexchange.com/filters/167317/gitpython)
-- Please post on Stack Overflow and use the `gitpython` tag
-- [Issue Tracker](https://github.com/gitpython-developers/GitPython/issues)
-  - Post reproducible bugs and feature requests as a new issue.
-    Please be sure to provide the following information if posting bugs:
-    - GitPython version (e.g. `import git; git.__version__`)
-    - Python version (e.g. `python --version`)
-    - The encountered stack-trace, if applicable
-    - Enough information to allow reproducing the issue
-
-### How to make a new release
-
-1. Update/verify the **version** in the `VERSION` file.
-2. Update/verify that the `doc/source/changes.rst` changelog file was updated. It should include a link to the forthcoming release page: `https://github.com/gitpython-developers/GitPython/releases/tag/<version>`
-3. Commit everything.
-4. Run `git tag -s <version>` to tag the version in Git.
-5. _Optionally_ create and activate a [virtual environment](https://packaging.python.org/en/latest/guides/installing-using-pip-and-virtual-environments/#creating-a-virtual-environment). (Then the next step can install `build` and `twine`.)
-6. Run `make release`.
-7. Go to [GitHub Releases](https://github.com/gitpython-developers/GitPython/releases) and publish a new one with the recently pushed tag. Generate the changelog.
-
-### Projects using GitPython
-
-- [PyDriller](https://github.com/ishepard/pydriller)
-- [Kivy Designer](https://github.com/kivy/kivy-designer)
-- [Prowl](https://github.com/nettitude/Prowl)
-- [Python Taint](https://github.com/python-security/pyt)
-- [Buster](https://github.com/axitkhurana/buster)
-- [git-ftp](https://github.com/ezyang/git-ftp)
-- [Git-Pandas](https://github.com/wdm0006/git-pandas)
-- [PyGitUp](https://github.com/msiemens/PyGitUp)
-- [PyJFuzz](https://github.com/mseclab/PyJFuzz)
-- [Loki](https://github.com/Neo23x0/Loki)
-- [Omniwallet](https://github.com/OmniLayer/omniwallet)
-- [GitViper](https://github.com/BeayemX/GitViper)
-- [Git Gud](https://github.com/bthayer2365/git-gud)
-
-### LICENSE
-
-[3-Clause BSD License](https://opensource.org/license/bsd-3-clause/), also known as the New BSD License. See the [LICENSE file][license].
-
-[contributing]: https://github.com/gitpython-developers/GitPython/blob/main/CONTRIBUTING.md
-[license]: https://github.com/gitpython-developers/GitPython/blob/main/LICENSE

ILYA/Lib/site-packages/GitPython-3.1.43.dist-info/RECORD

@@ -1,83 +0,0 @@
-GitPython-3.1.43.dist-info/AUTHORS,sha256=h1TlPKfp05GA1eKQ15Yl4biR0C0FgivuGSeRA6Q1dz0,2286
-GitPython-3.1.43.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
-GitPython-3.1.43.dist-info/LICENSE,sha256=hvyUwyGpr7wRUUcTURuv3tIl8lEA3MD3NQ6CvCMbi-s,1503
-GitPython-3.1.43.dist-info/METADATA,sha256=sAh3r1BMVw5_olGgDmpMS69zBpVr7UEOeRivNHKznfU,13376
-GitPython-3.1.43.dist-info/RECORD,,
-GitPython-3.1.43.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GitPython-3.1.43.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-GitPython-3.1.43.dist-info/top_level.txt,sha256=0hzDuIp8obv624V3GmbqsagBWkk8ohtGU-Bc1PmTT0o,4
-git/__init__.py,sha256=w6fnS0QmwTfEFUSL6rfnpP0lUId2goSguZFOvVX3N3U,8899
-git/__pycache__/__init__.cpython-311.pyc,,
-git/__pycache__/cmd.cpython-311.pyc,,
-git/__pycache__/compat.cpython-311.pyc,,
-git/__pycache__/config.cpython-311.pyc,,
-git/__pycache__/db.cpython-311.pyc,,
-git/__pycache__/diff.cpython-311.pyc,,
-git/__pycache__/exc.cpython-311.pyc,,
-git/__pycache__/remote.cpython-311.pyc,,
-git/__pycache__/types.cpython-311.pyc,,
-git/__pycache__/util.cpython-311.pyc,,
-git/cmd.py,sha256=qd-gIHSk4mfsYjd9YA08cPyO8TMxaibTXAbFnHK71uc,67659
-git/compat.py,sha256=y1E6y6O2q5r8clSlr8ZNmuIWG9nmHuehQEsVsmBffs8,4526
-git/config.py,sha256=Ald8Xc-G9Shcgx3QCISyXTkL4a6nbc3qll-xUw4YdyY,34924
-git/db.py,sha256=vIW9uWSbqu99zbuU2ZDmOhVOv1UPTmxrnqiCtRHCfjE,2368
-git/diff.py,sha256=IE5aeHL7aP9yxBluYj06IX8nZjoJ_TOM3gG31-Evf_8,27058
-git/exc.py,sha256=Gc7g1pHpn8OmTse30NHmJVsBJ2CYH8LxaR8y8UA3lIM,7119
-git/index/__init__.py,sha256=i-Nqb8Lufp9aFbmxpQBORmmQnjEVVM1Pn58fsQkyGgQ,406
-git/index/__pycache__/__init__.cpython-311.pyc,,
-git/index/__pycache__/base.cpython-311.pyc,,
-git/index/__pycache__/fun.cpython-311.pyc,,
-git/index/__pycache__/typ.cpython-311.pyc,,
-git/index/__pycache__/util.cpython-311.pyc,,
-git/index/base.py,sha256=A4q4cN_Ifxi8CsAR-7h4KsQ2d3JazBNFZ1ltbAKttgs,60734
-git/index/fun.py,sha256=37cA3DBC9vpAnSVu5TGA072SnoF5XZOkOukExwlejHs,16736
-git/index/typ.py,sha256=uuKNwitUw83FhVaLSwo4pY7PHDQudtZTLJrLGym4jcI,6570
-git/index/util.py,sha256=fULi7GPG-MvprKrRCD5c15GNdzku_1E38We0d97WB3A,3659
-git/objects/__init__.py,sha256=O6ZL_olX7e5-8iIbKviRPkVSJxN37WA-EC0q9d48U5Y,637
-git/objects/__pycache__/__init__.cpython-311.pyc,,
-git/objects/__pycache__/base.cpython-311.pyc,,
-git/objects/__pycache__/blob.cpython-311.pyc,,
-git/objects/__pycache__/commit.cpython-311.pyc,,
-git/objects/__pycache__/fun.cpython-311.pyc,,
-git/objects/__pycache__/tag.cpython-311.pyc,,
-git/objects/__pycache__/tree.cpython-311.pyc,,
-git/objects/__pycache__/util.cpython-311.pyc,,
-git/objects/base.py,sha256=0dqNkSRVH0mk0-7ZKIkGBK7iNYrzLTVxwQFUd6CagsE,10277
-git/objects/blob.py,sha256=zwwq0KfOMYeP5J2tW5CQatoLyeqFRlfkxP1Vwx1h07s,1215
-git/objects/commit.py,sha256=vLZNl1I9zp17Rpge7J66CvsryirEs90jyPTQzoP0JJs,30208
-git/objects/fun.py,sha256=B4jCqhAjm6Hl79GK58FPzW1H9K6Wc7Tx0rssyWmAcEE,8935
-git/objects/submodule/__init__.py,sha256=6xySp767LVz3UylWgUalntS_nGXRuVzXxDuFAv_Wc2c,303
-git/objects/submodule/__pycache__/__init__.cpython-311.pyc,,
-git/objects/submodule/__pycache__/base.cpython-311.pyc,,
-git/objects/submodule/__pycache__/root.cpython-311.pyc,,
-git/objects/submodule/__pycache__/util.cpython-311.pyc,,
-git/objects/submodule/base.py,sha256=MQ-2xV8JznGwy2hLQv1aeQNgAkhBhgc5tdtClFL3DmE,63901
-git/objects/submodule/root.py,sha256=5eTtYNHasqdPq6q0oDCPr7IaO6uAHL3b4DxMoiO2LhE,20246
-git/objects/submodule/util.py,sha256=sQqAYaiSJdFkZa9NlAuK_wTsMNiS-kkQnQjvIoJtc_o,3509
-git/objects/tag.py,sha256=gAx8i-DEwy_Z3R2zLkvetYRV8A56BCcTr3iLuTUTfEM,4467
-git/objects/tree.py,sha256=jJH888SHiP4dGzE-ra1yenQOyya_0C_MkHr06c1gHpM,13849
-git/objects/util.py,sha256=Ml2eqZPKO4y9Hc2vWbXJgpsK3nkN3KGMzbn8AlzLyYQ,23834
-git/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-git/refs/__init__.py,sha256=DWlJNnsx-4jM_E-VycbP-FZUdn6iWhjnH_uZ_pZXBro,509
-git/refs/__pycache__/__init__.cpython-311.pyc,,
-git/refs/__pycache__/head.cpython-311.pyc,,
-git/refs/__pycache__/log.cpython-311.pyc,,
-git/refs/__pycache__/reference.cpython-311.pyc,,
-git/refs/__pycache__/remote.cpython-311.pyc,,
-git/refs/__pycache__/symbolic.cpython-311.pyc,,
-git/refs/__pycache__/tag.cpython-311.pyc,,
-git/refs/head.py,sha256=GAZpD5EfqSciDXPtgjHY8ZbBixKExJRhojUB-HrrJPg,10491
-git/refs/log.py,sha256=kXiuAgTo1DIuM_BfbDUk9gQ0YO-mutIMVdHv1_ES90o,12493
-git/refs/reference.py,sha256=l6mhF4YLSEwtjz6b9PpOQH-fkng7EYWMaJhkjn-2jXA,5630
-git/refs/remote.py,sha256=WwqV9T7BbYf3F_WZNUQivu9xktIIKGklCjDpwQrhD-A,2806
-git/refs/symbolic.py,sha256=c8zOwaqzcg-J-rGrpuWdvh8zwMvSUqAHghd4vJoYG_s,34552
-git/refs/tag.py,sha256=kgzV2vhpL4FD2TqHb0BJuMRAHgAvJF-TcoyWlaB-djQ,5010
-git/remote.py,sha256=IHQ3BvXgoIN1EvHlyH3vrSaQoDkLOE6nooSC0w183sU,46561
-git/repo/__init__.py,sha256=CILSVH36fX_WxVFSjD9o1WF5LgsNedPiJvSngKZqfVU,210
-git/repo/__pycache__/__init__.cpython-311.pyc,,
-git/repo/__pycache__/base.cpython-311.pyc,,
-git/repo/__pycache__/fun.cpython-311.pyc,,
-git/repo/base.py,sha256=mitfJ8u99CsMpDd7_VRyx-SF8omu2tpf3lqzSaQkKoQ,59353
-git/repo/fun.py,sha256=tEsClpmbOrKMSNIdncOB_6JdikrL1-AfkOFd7xMpD8k,13582
-git/types.py,sha256=xCwpp2Y01lhS0MapHhj04m0P_x34kwSD1Gsou_ZPWj8,10251
-git/util.py,sha256=1E883mnPAFLyFk7ivwnEremsp-uJOTc3ks_QypyLung,43651

ILYA/Lib/site-packages/GitPython-3.1.43.dist-info/WHEEL

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

ILYA/Lib/site-packages/GitPython-3.1.43.dist-info/top_level.txt

@@ -1 +0,0 @@
-git

ILYA/Lib/site-packages/git/__init__.py

@@ -1,300 +0,0 @@
-# Copyright (C) 2008, 2009 Michael Trier ([email protected]) and contributors
-#
-# This module is part of GitPython and is released under the
-# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
-
-# @PydevCodeAnalysisIgnore
-
-__all__ = [
-    "Actor",
-    "AmbiguousObjectName",
-    "BadName",
-    "BadObject",
-    "BadObjectType",
-    "BaseIndexEntry",
-    "Blob",
-    "BlobFilter",
-    "BlockingLockFile",
-    "CacheError",
-    "CheckoutError",
-    "CommandError",
-    "Commit",
-    "Diff",
-    "DiffConstants",
-    "DiffIndex",
-    "Diffable",
-    "FetchInfo",
-    "Git",
-    "GitCmdObjectDB",
-    "GitCommandError",
-    "GitCommandNotFound",
-    "GitConfigParser",
-    "GitDB",
-    "GitError",
-    "HEAD",
-    "Head",
-    "HookExecutionError",
-    "INDEX",
-    "IndexEntry",
-    "IndexFile",
-    "IndexObject",
-    "InvalidDBRoot",
-    "InvalidGitRepositoryError",
-    "List",  # Deprecated - import this from `typing` instead.
-    "LockFile",
-    "NULL_TREE",
-    "NoSuchPathError",
-    "ODBError",
-    "Object",
-    "Optional",  # Deprecated - import this from `typing` instead.
-    "ParseError",
-    "PathLike",
-    "PushInfo",
-    "RefLog",
-    "RefLogEntry",
-    "Reference",
-    "Remote",
-    "RemoteProgress",
-    "RemoteReference",
-    "Repo",
-    "RepositoryDirtyError",
-    "RootModule",
-    "RootUpdateProgress",
-    "Sequence",  # Deprecated - import from `typing`, or `collections.abc` in 3.9+.
-    "StageType",
-    "Stats",
-    "Submodule",
-    "SymbolicReference",
-    "TYPE_CHECKING",  # Deprecated - import this from `typing` instead.
-    "Tag",
-    "TagObject",
-    "TagReference",
-    "Tree",
-    "TreeModifier",
-    "Tuple",  # Deprecated - import this from `typing` instead.
-    "Union",  # Deprecated - import this from `typing` instead.
-    "UnmergedEntriesError",
-    "UnsafeOptionError",
-    "UnsafeProtocolError",
-    "UnsupportedOperation",
-    "UpdateProgress",
-    "WorkTreeRepositoryUnsupported",
-    "refresh",
-    "remove_password_if_present",
-    "rmtree",
-    "safe_decode",
-    "to_hex_sha",
-]
-
-__version__ = '3.1.43'
-
-from typing import Any, List, Optional, Sequence, TYPE_CHECKING, Tuple, Union
-
-if TYPE_CHECKING:
-    from types import ModuleType
-
-import warnings
-
-from gitdb.util import to_hex_sha
-
-from git.exc import (
-    AmbiguousObjectName,
-    BadName,
-    BadObject,
-    BadObjectType,
-    CacheError,
-    CheckoutError,
-    CommandError,
-    GitCommandError,
-    GitCommandNotFound,
-    GitError,
-    HookExecutionError,
-    InvalidDBRoot,
-    InvalidGitRepositoryError,
-    NoSuchPathError,
-    ODBError,
-    ParseError,
-    RepositoryDirtyError,
-    UnmergedEntriesError,
-    UnsafeOptionError,
-    UnsafeProtocolError,
-    UnsupportedOperation,
-    WorkTreeRepositoryUnsupported,
-)
-from git.types import PathLike
-
-try:
-    from git.compat import safe_decode  # @NoMove
-    from git.config import GitConfigParser  # @NoMove
-    from git.objects import (  # @NoMove
-        Blob,
-        Commit,
-        IndexObject,
-        Object,
-        RootModule,
-        RootUpdateProgress,
-        Submodule,
-        TagObject,
-        Tree,
-        TreeModifier,
-        UpdateProgress,
-    )
-    from git.refs import (  # @NoMove
-        HEAD,
-        Head,
-        RefLog,
-        RefLogEntry,
-        Reference,
-        RemoteReference,
-        SymbolicReference,
-        Tag,
-        TagReference,
-    )
-    from git.diff import (  # @NoMove
-        INDEX,
-        NULL_TREE,
-        Diff,
-        DiffConstants,
-        DiffIndex,
-        Diffable,
-    )
-    from git.db import GitCmdObjectDB, GitDB  # @NoMove
-    from git.cmd import Git  # @NoMove
-    from git.repo import Repo  # @NoMove
-    from git.remote import FetchInfo, PushInfo, Remote, RemoteProgress  # @NoMove
-    from git.index import (  # @NoMove
-        BaseIndexEntry,
-        BlobFilter,
-        CheckoutError,
-        IndexEntry,
-        IndexFile,
-        StageType,
-        # NOTE: This tells type checkers what util resolves to. We delete it, and it is
-        # really resolved by __getattr__, which warns. See below on what to use instead.
-        util,
-    )
-    from git.util import (  # @NoMove
-        Actor,
-        BlockingLockFile,
-        LockFile,
-        Stats,
-        remove_password_if_present,
-        rmtree,
-    )
-except GitError as _exc:
-    raise ImportError("%s: %s" % (_exc.__class__.__name__, _exc)) from _exc
-
-
-def _warned_import(message: str, fullname: str) -> "ModuleType":
-    import importlib
-
-    warnings.warn(message, DeprecationWarning, stacklevel=3)
-    return importlib.import_module(fullname)
-
-
-def _getattr(name: str) -> Any:
-    # TODO: If __version__ is made dynamic and lazily fetched, put that case right here.
-
-    if name == "util":
-        return _warned_import(
-            "The expression `git.util` and the import `from git import util` actually "
-            "reference git.index.util, and not the git.util module accessed in "
-            '`from git.util import XYZ` or `sys.modules["git.util"]`. This potentially '
-            "confusing behavior is currently preserved for compatibility, but may be "
-            "changed in the future and should not be relied on.",
-            fullname="git.index.util",
-        )
-
-    for names, prefix in (
-        ({"head", "log", "reference", "symbolic", "tag"}, "git.refs"),
-        ({"base", "fun", "typ"}, "git.index"),
-    ):
-        if name not in names:
-            continue
-
-        fullname = f"{prefix}.{name}"
-
-        return _warned_import(
-            f"{__name__}.{name} is a private alias of {fullname} and subject to "
-            f"immediate removal. Use {fullname} instead.",
-            fullname=fullname,
-        )
-
-    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
-
-
-if not TYPE_CHECKING:
-    # NOTE: The expression `git.util` gives git.index.util and `from git import util`
-    # imports git.index.util, NOT git.util. It may not be feasible to change this until
-    # the next major version, to avoid breaking code inadvertently relying on it.
-    #
-    # - If git.index.util *is* what you want, use (or import from) that, to avoid
-    #   confusion.
-    #
-    # - To use the "real" git.util module, write `from git.util import ...`, or if
-    #   necessary access it as `sys.modules["git.util"]`.
-    #
-    # Note also that `import git.util` technically imports the "real" git.util... but
-    # the *expression* `git.util` after doing so is still git.index.util!
-    #
-    # (This situation differs from that of other indirect-submodule imports that are
-    # unambiguously non-public and subject to immediate removal. Here, the public
-    # git.util module, though different, makes less discoverable that the expression
-    # `git.util` refers to a non-public attribute of the git module.)
-    #
-    # This had originally come about by a wildcard import. Now that all intended imports
-    # are explicit, the intuitive but potentially incompatible binding occurs due to the
-    # usual rules for Python submodule bindings. So for now we replace that binding with
-    # git.index.util, delete that, and let __getattr__ handle it and issue a warning.
-    #
-    # For the same runtime behavior, it would be enough to forgo importing util, and
-    # delete util as created naturally; __getattr__ would behave the same. But type
-    # checkers would not know what util refers to when accessed as an attribute of git.
-    del util
-
-    # This is "hidden" to preserve static checking for undefined/misspelled attributes.
-    __getattr__ = _getattr
-
-# { Initialize git executable path
-
-GIT_OK = None
-
-
-def refresh(path: Optional[PathLike] = None) -> None:
-    """Convenience method for setting the git executable path.
-
-    :param path:
-        Optional path to the Git executable. If not absolute, it is resolved
-        immediately, relative to the current directory.
-
-    :note:
-        The `path` parameter is usually omitted and cannot be used to specify a custom
-        command whose location is looked up in a path search on each call. See
-        :meth:`Git.refresh <git.cmd.Git.refresh>` for details on how to achieve this.
-
-    :note:
-        This calls :meth:`Git.refresh <git.cmd.Git.refresh>` and sets other global
-        configuration according to the effect of doing so. As such, this function should
-        usually be used instead of using :meth:`Git.refresh <git.cmd.Git.refresh>` or
-        :meth:`FetchInfo.refresh <git.remote.FetchInfo.refresh>` directly.
-
-    :note:
-        This function is called automatically, with no arguments, at import time.
-    """
-    global GIT_OK
-    GIT_OK = False
-
-    if not Git.refresh(path=path):
-        return
-    if not FetchInfo.refresh():  # noqa: F405
-        return  # type: ignore[unreachable]
-
-    GIT_OK = True
-
-
-try:
-    refresh()
-except Exception as _exc:
-    raise ImportError("Failed to initialize: {0}".format(_exc)) from _exc
-
-# } END initialize git executable path

ILYA/Lib/site-packages/git/cmd.py

@@ -1,1723 +0,0 @@
-# Copyright (C) 2008, 2009 Michael Trier ([email protected]) and contributors
-#
-# This module is part of GitPython and is released under the
-# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
-
-from __future__ import annotations
-
-__all__ = ["GitMeta", "Git"]
-
-import contextlib
-import io
-import itertools
-import logging
-import os
-import re
-import signal
-import subprocess
-from subprocess import DEVNULL, PIPE, Popen
-import sys
-from textwrap import dedent
-import threading
-import warnings
-
-from git.compat import defenc, force_bytes, safe_decode
-from git.exc import (
-    CommandError,
-    GitCommandError,
-    GitCommandNotFound,
-    UnsafeOptionError,
-    UnsafeProtocolError,
-)
-from git.util import (
-    cygpath,
-    expand_path,
-    is_cygwin_git,
-    patch_env,
-    remove_password_if_present,
-    stream_copy,
-)
-
-# typing ---------------------------------------------------------------------------
-
-from typing import (
-    Any,
-    AnyStr,
-    BinaryIO,
-    Callable,
-    Dict,
-    IO,
-    Iterator,
-    List,
-    Mapping,
-    Optional,
-    Sequence,
-    TYPE_CHECKING,
-    TextIO,
-    Tuple,
-    Union,
-    cast,
-    overload,
-)
-
-from git.types import Literal, PathLike, TBD
-
-if TYPE_CHECKING:
-    from git.diff import DiffIndex
-    from git.repo.base import Repo
-
-# ---------------------------------------------------------------------------------
-
-execute_kwargs = {
-    "istream",
-    "with_extended_output",
-    "with_exceptions",
-    "as_process",
-    "output_stream",
-    "stdout_as_string",
-    "kill_after_timeout",
-    "with_stdout",
-    "universal_newlines",
-    "shell",
-    "env",
-    "max_chunk_size",
-    "strip_newline_in_stdout",
-}
-
-_logger = logging.getLogger(__name__)
-
-
-# ==============================================================================
-## @name Utilities
-# ------------------------------------------------------------------------------
-# Documentation
-## @{
-
-
-def handle_process_output(
-    process: "Git.AutoInterrupt" | Popen,
-    stdout_handler: Union[
-        None,
-        Callable[[AnyStr], None],
-        Callable[[List[AnyStr]], None],
-        Callable[[bytes, "Repo", "DiffIndex"], None],
-    ],
-    stderr_handler: Union[None, Callable[[AnyStr], None], Callable[[List[AnyStr]], None]],
-    finalizer: Union[None, Callable[[Union[Popen, "Git.AutoInterrupt"]], None]] = None,
-    decode_streams: bool = True,
-    kill_after_timeout: Union[None, float] = None,
-) -> None:
-    R"""Register for notifications to learn that process output is ready to read, and
-    dispatch lines to the respective line handlers.
-
-    This function returns once the finalizer returns.
-
-    :param process:
-        :class:`subprocess.Popen` instance.
-
-    :param stdout_handler:
-        f(stdout_line_string), or ``None``.
-
-    :param stderr_handler:
-        f(stderr_line_string), or ``None``.
-
-    :param finalizer:
-        f(proc) - wait for proc to finish.
-
-    :param decode_streams:
-        Assume stdout/stderr streams are binary and decode them before pushing their
-        contents to handlers.
-
-        This defaults to ``True``. Set it to ``False`` if:
-
-        - ``universal_newlines == True``, as then streams are in text mode, or
-        - decoding must happen later, such as for :class:`~git.diff.Diff`\s.
-
-    :param kill_after_timeout:
-        :class:`float` or ``None``, Default = ``None``
-
-        To specify a timeout in seconds for the git command, after which the process
-        should be killed.
-    """
-
-    # Use 2 "pump" threads and wait for both to finish.
-    def pump_stream(
-        cmdline: List[str],
-        name: str,
-        stream: Union[BinaryIO, TextIO],
-        is_decode: bool,
-        handler: Union[None, Callable[[Union[bytes, str]], None]],
-    ) -> None:
-        try:
-            for line in stream:
-                if handler:
-                    if is_decode:
-                        assert isinstance(line, bytes)
-                        line_str = line.decode(defenc)
-                        handler(line_str)
-                    else:
-                        handler(line)
-
-        except Exception as ex:
-            _logger.error(f"Pumping {name!r} of cmd({remove_password_if_present(cmdline)}) failed due to: {ex!r}")
-            if "I/O operation on closed file" not in str(ex):
-                # Only reraise if the error was not due to the stream closing.
-                raise CommandError([f"<{name}-pump>"] + remove_password_if_present(cmdline), ex) from ex
-        finally:
-            stream.close()
-
-    if hasattr(process, "proc"):
-        process = cast("Git.AutoInterrupt", process)
-        cmdline: str | Tuple[str, ...] | List[str] = getattr(process.proc, "args", "")
-        p_stdout = process.proc.stdout if process.proc else None
-        p_stderr = process.proc.stderr if process.proc else None
-    else:
-        process = cast(Popen, process)  # type: ignore[redundant-cast]
-        cmdline = getattr(process, "args", "")
-        p_stdout = process.stdout
-        p_stderr = process.stderr
-
-    if not isinstance(cmdline, (tuple, list)):
-        cmdline = cmdline.split()
-
-    pumps: List[Tuple[str, IO, Callable[..., None] | None]] = []
-    if p_stdout:
-        pumps.append(("stdout", p_stdout, stdout_handler))
-    if p_stderr:
-        pumps.append(("stderr", p_stderr, stderr_handler))
-
-    threads: List[threading.Thread] = []
-
-    for name, stream, handler in pumps:
-        t = threading.Thread(target=pump_stream, args=(cmdline, name, stream, decode_streams, handler))
-        t.daemon = True
-        t.start()
-        threads.append(t)
-
-    # FIXME: Why join? Will block if stdin needs feeding...
-    for t in threads:
-        t.join(timeout=kill_after_timeout)
-        if t.is_alive():
-            if isinstance(process, Git.AutoInterrupt):
-                process._terminate()
-            else:  # Don't want to deal with the other case.
-                raise RuntimeError(
-                    "Thread join() timed out in cmd.handle_process_output()."
-                    f" kill_after_timeout={kill_after_timeout} seconds"
-                )
-            if stderr_handler:
-                error_str: Union[str, bytes] = (
-                    "error: process killed because it timed out." f" kill_after_timeout={kill_after_timeout} seconds"
-                )
-                if not decode_streams and isinstance(p_stderr, BinaryIO):
-                    # Assume stderr_handler needs binary input.
-                    error_str = cast(str, error_str)
-                    error_str = error_str.encode()
-                # We ignore typing on the next line because mypy does not like the way
-                # we inferred that stderr takes str or bytes.
-                stderr_handler(error_str)  # type: ignore[arg-type]
-
-    if finalizer:
-        finalizer(process)
-
-
-safer_popen: Callable[..., Popen]
-
-if sys.platform == "win32":
-
-    def _safer_popen_windows(
-        command: Union[str, Sequence[Any]],
-        *,
-        shell: bool = False,
-        env: Optional[Mapping[str, str]] = None,
-        **kwargs: Any,
-    ) -> Popen:
-        """Call :class:`subprocess.Popen` on Windows but don't include a CWD in the
-        search.
-
-        This avoids an untrusted search path condition where a file like ``git.exe`` in
-        a malicious repository would be run when GitPython operates on the repository.
-        The process using GitPython may have an untrusted repository's working tree as
-        its current working directory. Some operations may temporarily change to that
-        directory before running a subprocess. In addition, while by default GitPython
-        does not run external commands with a shell, it can be made to do so, in which
-        case the CWD of the subprocess, which GitPython usually sets to a repository
-        working tree, can itself be searched automatically by the shell. This wrapper
-        covers all those cases.
-
-        :note:
-            This currently works by setting the
-            :envvar:`NoDefaultCurrentDirectoryInExePath` environment variable during
-            subprocess creation. It also takes care of passing Windows-specific process
-            creation flags, but that is unrelated to path search.
-
-        :note:
-            The current implementation contains a race condition on :attr:`os.environ`.
-            GitPython isn't thread-safe, but a program using it on one thread should
-            ideally be able to mutate :attr:`os.environ` on another, without
-            unpredictable results. See comments in:
-            https://github.com/gitpython-developers/GitPython/pull/1650
-        """
-        # CREATE_NEW_PROCESS_GROUP is needed for some ways of killing it afterwards.
-        # https://docs.python.org/3/library/subprocess.html#subprocess.Popen.send_signal
-        # https://docs.python.org/3/library/subprocess.html#subprocess.CREATE_NEW_PROCESS_GROUP
-        creationflags = subprocess.CREATE_NO_WINDOW | subprocess.CREATE_NEW_PROCESS_GROUP
-
-        # When using a shell, the shell is the direct subprocess, so the variable must
-        # be set in its environment, to affect its search behavior.
-        if shell:
-            # The original may be immutable, or the caller may reuse it. Mutate a copy.
-            env = {} if env is None else dict(env)
-            env["NoDefaultCurrentDirectoryInExePath"] = "1"  # The "1" can be an value.
-
-        # When not using a shell, the current process does the search in a
-        # CreateProcessW API call, so the variable must be set in our environment. With
-        # a shell, that's unnecessary if https://github.com/python/cpython/issues/101283
-        # is patched. In Python versions where it is unpatched, and in the rare case the
-        # ComSpec environment variable is unset, the search for the shell itself is
-        # unsafe. Setting NoDefaultCurrentDirectoryInExePath in all cases, as done here,
-        # is simpler and protects against that. (As above, the "1" can be any value.)
-        with patch_env("NoDefaultCurrentDirectoryInExePath", "1"):
-            return Popen(
-                command,
-                shell=shell,
-                env=env,
-                creationflags=creationflags,
-                **kwargs,
-            )
-
-    safer_popen = _safer_popen_windows
-else:
-    safer_popen = Popen
-
-
-def dashify(string: str) -> str:
-    return string.replace("_", "-")
-
-
-def slots_to_dict(self: "Git", exclude: Sequence[str] = ()) -> Dict[str, Any]:
-    return {s: getattr(self, s) for s in self.__slots__ if s not in exclude}
-
-
-def dict_to_slots_and__excluded_are_none(self: object, d: Mapping[str, Any], excluded: Sequence[str] = ()) -> None:
-    for k, v in d.items():
-        setattr(self, k, v)
-    for k in excluded:
-        setattr(self, k, None)
-
-
-## -- End Utilities -- @}
-
-_USE_SHELL_DEFAULT_MESSAGE = (
-    "Git.USE_SHELL is deprecated, because only its default value of False is safe. "
-    "It will be removed in a future release."
-)
-
-_USE_SHELL_DANGER_MESSAGE = (
-    "Setting Git.USE_SHELL to True is unsafe and insecure, as the effect of special "
-    "shell syntax cannot usually be accounted for. This can result in a command "
-    "injection vulnerability and arbitrary code execution. Git.USE_SHELL is deprecated "
-    "and will be removed in a future release."
-)
-
-
-def _warn_use_shell(extra_danger: bool) -> None:
-    warnings.warn(
-        _USE_SHELL_DANGER_MESSAGE if extra_danger else _USE_SHELL_DEFAULT_MESSAGE,
-        DeprecationWarning,
-        stacklevel=3,
-    )
-
-
-class _GitMeta(type):
-    """Metaclass for :class:`Git`.
-
-    This helps issue :class:`DeprecationWarning` if :attr:`Git.USE_SHELL` is used.
-    """
-
-    def __getattribute(cls, name: str) -> Any:
-        if name == "USE_SHELL":
-            _warn_use_shell(False)
-        return super().__getattribute__(name)
-
-    def __setattr(cls, name: str, value: Any) -> Any:
-        if name == "USE_SHELL":
-            _warn_use_shell(value)
-        super().__setattr__(name, value)
-
-    if not TYPE_CHECKING:
-        # To preserve static checking for undefined/misspelled attributes while letting
-        # the methods' bodies be type-checked, these are defined as non-special methods,
-        # then bound to special names out of view of static type checkers. (The original
-        # names invoke name mangling (leading "__") to avoid confusion in other scopes.)
-        __getattribute__ = __getattribute
-        __setattr__ = __setattr
-
-
-GitMeta = _GitMeta
-"""Alias of :class:`Git`'s metaclass, whether it is :class:`type` or a custom metaclass.
-
-Whether the :class:`Git` class has the default :class:`type` as its metaclass or uses a
-custom metaclass is not documented and may change at any time. This statically checkable
-metaclass alias is equivalent at runtime to ``type(Git)``. This should almost never be
-used. Code that benefits from it is likely to be remain brittle even if it is used.
-
-In view of the :class:`Git` class's intended use and :class:`Git` objects' dynamic
-callable attributes representing git subcommands, it rarely makes sense to inherit from
-:class:`Git` at all. Using :class:`Git` in multiple inheritance can be especially tricky
-to do correctly. Attempting uses of :class:`Git` where its metaclass is relevant, such
-as when a sibling class has an unrelated metaclass and a shared lower bound metaclass
-might have to be introduced to solve a metaclass conflict, is not recommended.
-
-:note:
-    The correct static type of the :class:`Git` class itself, and any subclasses, is
-    ``Type[Git]``. (This can be written as ``type[Git]`` in Python 3.9 later.)
-
-    :class:`GitMeta` should never be used in any annotation where ``Type[Git]`` is
-    intended or otherwise possible to use. This alias is truly only for very rare and
-    inherently precarious situations where it is necessary to deal with the metaclass
-    explicitly.
-"""
-
-
-class Git(metaclass=_GitMeta):
-    """The Git class manages communication with the Git binary.
-
-    It provides a convenient interface to calling the Git binary, such as in::
-
-     g = Git( git_dir )
-     g.init()                   # calls 'git init' program
-     rval = g.ls_files()        # calls 'git ls-files' program
-
-    Debugging:
-
-    * Set the :envvar:`GIT_PYTHON_TRACE` environment variable to print each invocation
-      of the command to stdout.
-    * Set its value to ``full`` to see details about the returned values.
-    """
-
-    __slots__ = (
-        "_working_dir",
-        "cat_file_all",
-        "cat_file_header",
-        "_version_info",
-        "_version_info_token",
-        "_git_options",
-        "_persistent_git_options",
-        "_environment",
-    )
-
-    _excluded_ = (
-        "cat_file_all",
-        "cat_file_header",
-        "_version_info",
-        "_version_info_token",
-    )
-
-    re_unsafe_protocol = re.compile(r"(.+)::.+")
-
-    def __getstate__(self) -> Dict[str, Any]:
-        return slots_to_dict(self, exclude=self._excluded_)
-
-    def __setstate__(self, d: Dict[str, Any]) -> None:
-        dict_to_slots_and__excluded_are_none(self, d, excluded=self._excluded_)
-
-    # CONFIGURATION
-
-    git_exec_name = "git"
-    """Default git command that should work on Linux, Windows, and other systems."""
-
-    GIT_PYTHON_TRACE = os.environ.get("GIT_PYTHON_TRACE", False)
-    """Enables debugging of GitPython's git commands."""
-
-    USE_SHELL: bool = False
-    """Deprecated. If set to ``True``, a shell will be used when executing git commands.
-
-    Code that uses ``USE_SHELL = True`` or that passes ``shell=True`` to any GitPython
-    functions should be updated to use the default value of ``False`` instead. ``True``
-    is unsafe unless the effect of syntax treated specially by the shell is fully
-    considered and accounted for, which is not possible under most circumstances. As
-    detailed below, it is also no longer needed, even where it had been in the past.
-
-    It is in many if not most cases a command injection vulnerability for an application
-    to set :attr:`USE_SHELL` to ``True``. Any attacker who can cause a specially crafted
-    fragment of text to make its way into any part of any argument to any git command
-    (including paths, branch names, etc.) can cause the shell to read and write
-    arbitrary files and execute arbitrary commands. Innocent input may also accidentally
-    contain special shell syntax, leading to inadvertent malfunctions.
-
-    In addition, how a value of ``True`` interacts with some aspects of GitPython's
-    operation is not precisely specified and may change without warning, even before
-    GitPython 4.0.0 when :attr:`USE_SHELL` may be removed. This includes:
-
-    * Whether or how GitPython automatically customizes the shell environment.
-
-    * Whether, outside of Windows (where :class:`subprocess.Popen` supports lists of
-      separate arguments even when ``shell=True``), this can be used with any GitPython
-      functionality other than direct calls to the :meth:`execute` method.
-
-    * Whether any GitPython feature that runs git commands ever attempts to partially
-      sanitize data a shell may treat specially. Currently this is not done.
-
-    Prior to GitPython 2.0.8, this had a narrow purpose in suppressing console windows
-    in graphical Windows applications. In 2.0.8 and higher, it provides no benefit, as
-    GitPython solves that problem more robustly and safely by using the
-    ``CREATE_NO_WINDOW`` process creation flag on Windows.
-
-    Because Windows path search differs subtly based on whether a shell is used, in rare
-    cases changing this from ``True`` to ``False`` may keep an unusual git "executable",
-    such as a batch file, from being found. To fix this, set the command name or full
-    path in the :envvar:`GIT_PYTHON_GIT_EXECUTABLE` environment variable or pass the
-    full path to :func:`git.refresh` (or invoke the script using a ``.exe`` shim).
-
-    Further reading:
-
-    * :meth:`Git.execute` (on the ``shell`` parameter).
-    * https://github.com/gitpython-developers/GitPython/commit/0d9390866f9ce42870d3116094cd49e0019a970a
-    * https://learn.microsoft.com/en-us/windows/win32/procthread/process-creation-flags
-    * https://github.com/python/cpython/issues/91558#issuecomment-1100942950
-    * https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createprocessw
-    """
-
-    _git_exec_env_var = "GIT_PYTHON_GIT_EXECUTABLE"
-    _refresh_env_var = "GIT_PYTHON_REFRESH"
-
-    GIT_PYTHON_GIT_EXECUTABLE = None
-    """Provide the full path to the git executable. Otherwise it assumes git is in the
-    executable search path.
-
-    :note:
-        The git executable is actually found during the refresh step in the top level
-        ``__init__``. It can also be changed by explicitly calling :func:`git.refresh`.
-    """
-
-    _refresh_token = object()  # Since None would match an initial _version_info_token.
-
-    @classmethod
-    def refresh(cls, path: Union[None, PathLike] = None) -> bool:
-        """Update information about the git executable :class:`Git` objects will use.
-
-        Called by the :func:`git.refresh` function in the top level ``__init__``.
-
-        :param path:
-            Optional path to the git executable. If not absolute, it is resolved
-            immediately, relative to the current directory. (See note below.)
-
-        :note:
-            The top-level :func:`git.refresh` should be preferred because it calls this
-            method and may also update other state accordingly.
-
-        :note:
-            There are three different ways to specify the command that refreshing causes
-            to be used for git:
-
-            1. Pass no `path` argument and do not set the
-               :envvar:`GIT_PYTHON_GIT_EXECUTABLE` environment variable. The command
-               name ``git`` is used. It is looked up in a path search by the system, in
-               each command run (roughly similar to how git is found when running
-               ``git`` commands manually). This is usually the desired behavior.
-
-            2. Pass no `path` argument but set the :envvar:`GIT_PYTHON_GIT_EXECUTABLE`
-               environment variable. The command given as the value of that variable is
-               used. This may be a simple command or an arbitrary path. It is looked up
-               in each command run. Setting :envvar:`GIT_PYTHON_GIT_EXECUTABLE` to
-               ``git`` has the same effect as not setting it.
-
-            3. Pass a `path` argument. This path, if not absolute, is immediately
-               resolved, relative to the current directory. This resolution occurs at
-               the time of the refresh. When git commands are run, they are run using
-               that previously resolved path. If a `path` argument is passed, the
-               :envvar:`GIT_PYTHON_GIT_EXECUTABLE` environment variable is not
-               consulted.
-
-        :note:
-            Refreshing always sets the :attr:`Git.GIT_PYTHON_GIT_EXECUTABLE` class
-            attribute, which can be read on the :class:`Git` class or any of its
-            instances to check what command is used to run git. This attribute should
-            not be confused with the related :envvar:`GIT_PYTHON_GIT_EXECUTABLE`
-            environment variable. The class attribute is set no matter how refreshing is
-            performed.
-        """
-        # Discern which path to refresh with.
-        if path is not None:
-            new_git = os.path.expanduser(path)
-            new_git = os.path.abspath(new_git)
-        else:
-            new_git = os.environ.get(cls._git_exec_env_var, cls.git_exec_name)
-
-        # Keep track of the old and new git executable path.
-        old_git = cls.GIT_PYTHON_GIT_EXECUTABLE
-        old_refresh_token = cls._refresh_token
-        cls.GIT_PYTHON_GIT_EXECUTABLE = new_git
-        cls._refresh_token = object()
-
-        # Test if the new git executable path is valid. A GitCommandNotFound error is
-        # raised by us. A PermissionError is raised if the git executable cannot be
-        # executed for whatever reason.
-        has_git = False
-        try:
-            cls().version()
-            has_git = True
-        except (GitCommandNotFound, PermissionError):
-            pass
-
-        # Warn or raise exception if test failed.
-        if not has_git:
-            err = (
-                dedent(
-                    """\
-                Bad git executable.
-                The git executable must be specified in one of the following ways:
-                    - be included in your $PATH
-                    - be set via $%s
-                    - explicitly set via git.refresh(<full-path-to-git-executable>)
-                """
-                )
-                % cls._git_exec_env_var
-            )
-
-            # Revert to whatever the old_git was.
-            cls.GIT_PYTHON_GIT_EXECUTABLE = old_git
-            cls._refresh_token = old_refresh_token
-
-            if old_git is None:
-                # On the first refresh (when GIT_PYTHON_GIT_EXECUTABLE is None) we only
-                # are quiet, warn, or error depending on the GIT_PYTHON_REFRESH value.
-
-                # Determine what the user wants to happen during the initial refresh. We
-                # expect GIT_PYTHON_REFRESH to either be unset or be one of the
-                # following values:
-                #
-                #   0|q|quiet|s|silence|silent|n|none
-                #   1|w|warn|warning|l|log
-                #   2|r|raise|e|error|exception
-
-                mode = os.environ.get(cls._refresh_env_var, "raise").lower()
-
-                quiet = ["quiet", "q", "silence", "s", "silent", "none", "n", "0"]
-                warn = ["warn", "w", "warning", "log", "l", "1"]
-                error = ["error", "e", "exception", "raise", "r", "2"]
-
-                if mode in quiet:
-                    pass
-                elif mode in warn or mode in error:
-                    err = dedent(
-                        """\
-                        %s
-                        All git commands will error until this is rectified.
-
-                        This initial message can be silenced or aggravated in the future by setting the
-                        $%s environment variable. Use one of the following values:
-                            - %s: for no message or exception
-                            - %s: for a warning message (logging level CRITICAL, displayed by default)
-                            - %s: for a raised exception
-
-                        Example:
-                            export %s=%s
-                        """
-                    ) % (
-                        err,
-                        cls._refresh_env_var,
-                        "|".join(quiet),
-                        "|".join(warn),
-                        "|".join(error),
-                        cls._refresh_env_var,
-                        quiet[0],
-                    )
-
-                    if mode in warn:
-                        _logger.critical(err)
-                    else:
-                        raise ImportError(err)
-                else:
-                    err = dedent(
-                        """\
-                        %s environment variable has been set but it has been set with an invalid value.
-
-                        Use only the following values:
-                            - %s: for no message or exception
-                            - %s: for a warning message (logging level CRITICAL, displayed by default)
-                            - %s: for a raised exception
-                        """
-                    ) % (
-                        cls._refresh_env_var,
-                        "|".join(quiet),
-                        "|".join(warn),
-                        "|".join(error),
-                    )
-                    raise ImportError(err)
-
-                # We get here if this was the initial refresh and the refresh mode was
-                # not error. Go ahead and set the GIT_PYTHON_GIT_EXECUTABLE such that we
-                # discern the difference between the first refresh at import time
-                # and subsequent calls to git.refresh or this refresh method.
-                cls.GIT_PYTHON_GIT_EXECUTABLE = cls.git_exec_name
-            else:
-                # After the first refresh (when GIT_PYTHON_GIT_EXECUTABLE is no longer
-                # None) we raise an exception.
-                raise GitCommandNotFound(new_git, err)
-
-        return has_git
-
-    @classmethod
-    def is_cygwin(cls) -> bool:
-        return is_cygwin_git(cls.GIT_PYTHON_GIT_EXECUTABLE)
-
-    @overload
-    @classmethod
-    def polish_url(cls, url: str, is_cygwin: Literal[False] = ...) -> str: ...
-
-    @overload
-    @classmethod
-    def polish_url(cls, url: str, is_cygwin: Union[None, bool] = None) -> str: ...
-
-    @classmethod
-    def polish_url(cls, url: str, is_cygwin: Union[None, bool] = None) -> PathLike:
-        """Remove any backslashes from URLs to be written in config files.
-
-        Windows might create config files containing paths with backslashes, but git
-        stops liking them as it will escape the backslashes. Hence we undo the escaping
-        just to be sure.
-        """
-        if is_cygwin is None:
-            is_cygwin = cls.is_cygwin()
-
-        if is_cygwin:
-            url = cygpath(url)
-        else:
-            url = os.path.expandvars(url)
-            if url.startswith("~"):
-                url = os.path.expanduser(url)
-            url = url.replace("\\\\", "\\").replace("\\", "/")
-        return url
-
-    @classmethod
-    def check_unsafe_protocols(cls, url: str) -> None:
-        """Check for unsafe protocols.
-
-        Apart from the usual protocols (http, git, ssh), Git allows "remote helpers"
-        that have the form ``<transport>::<address>``. One of these helpers (``ext::``)
-        can be used to invoke any arbitrary command.
-
-        See:
-
-        - https://git-scm.com/docs/gitremote-helpers
-        - https://git-scm.com/docs/git-remote-ext
-        """
-        match = cls.re_unsafe_protocol.match(url)
-        if match:
-            protocol = match.group(1)
-            raise UnsafeProtocolError(
-                f"The `{protocol}::` protocol looks suspicious, use `allow_unsafe_protocols=True` to allow it."
-            )
-
-    @classmethod
-    def check_unsafe_options(cls, options: List[str], unsafe_options: List[str]) -> None:
-        """Check for unsafe options.
-
-        Some options that are passed to ``git <command>`` can be used to execute
-        arbitrary commands. These are blocked by default.
-        """
-        # Options can be of the form `foo`, `--foo bar`, or `--foo=bar`, so we need to
-        # check if they start with "--foo" or if they are equal to "foo".
-        bare_unsafe_options = [option.lstrip("-") for option in unsafe_options]
-        for option in options:
-            for unsafe_option, bare_option in zip(unsafe_options, bare_unsafe_options):
-                if option.startswith(unsafe_option) or option == bare_option:
-                    raise UnsafeOptionError(
-                        f"{unsafe_option} is not allowed, use `allow_unsafe_options=True` to allow it."
-                    )
-
-    class AutoInterrupt:
-        """Process wrapper that terminates the wrapped process on finalization.
-
-        This kills/interrupts the stored process instance once this instance goes out of
-        scope. It is used to prevent processes piling up in case iterators stop reading.
-
-        All attributes are wired through to the contained process object.
-
-        The wait method is overridden to perform automatic status code checking and
-        possibly raise.
-        """
-
-        __slots__ = ("proc", "args", "status")
-
-        # If this is non-zero it will override any status code during _terminate, used
-        # to prevent race conditions in testing.
-        _status_code_if_terminate: int = 0
-
-        def __init__(self, proc: Union[None, subprocess.Popen], args: Any) -> None:
-            self.proc = proc
-            self.args = args
-            self.status: Union[int, None] = None
-
-        def _terminate(self) -> None:
-            """Terminate the underlying process."""
-            if self.proc is None:
-                return
-
-            proc = self.proc
-            self.proc = None
-            if proc.stdin:
-                proc.stdin.close()
-            if proc.stdout:
-                proc.stdout.close()
-            if proc.stderr:
-                proc.stderr.close()
-            # Did the process finish already so we have a return code?
-            try:
-                if proc.poll() is not None:
-                    self.status = self._status_code_if_terminate or proc.poll()
-                    return
-            except OSError as ex:
-                _logger.info("Ignored error after process had died: %r", ex)
-
-            # It can be that nothing really exists anymore...
-            if os is None or getattr(os, "kill", None) is None:
-                return
-
-            # Try to kill it.
-            try:
-                proc.terminate()
-                status = proc.wait()  # Ensure the process goes away.
-
-                self.status = self._status_code_if_terminate or status
-            except OSError as ex:
-                _logger.info("Ignored error after process had died: %r", ex)
-            # END exception handling
-
-        def __del__(self) -> None:
-            self._terminate()
-
-        def __getattr__(self, attr: str) -> Any:
-            return getattr(self.proc, attr)
-
-        # TODO: Bad choice to mimic `proc.wait()` but with different args.
-        def wait(self, stderr: Union[None, str, bytes] = b"") -> int:
-            """Wait for the process and return its status code.
-
-            :param stderr:
-                Previously read value of stderr, in case stderr is already closed.
-
-            :warn:
-                May deadlock if output or error pipes are used and not handled
-                separately.
-
-            :raise git.exc.GitCommandError:
-                If the return status is not 0.
-            """
-            if stderr is None:
-                stderr_b = b""
-            stderr_b = force_bytes(data=stderr, encoding="utf-8")
-            status: Union[int, None]
-            if self.proc is not None:
-                status = self.proc.wait()
-                p_stderr = self.proc.stderr
-            else:  # Assume the underlying proc was killed earlier or never existed.
-                status = self.status
-                p_stderr = None
-
-            def read_all_from_possibly_closed_stream(stream: Union[IO[bytes], None]) -> bytes:
-                if stream:
-                    try:
-                        return stderr_b + force_bytes(stream.read())
-                    except (OSError, ValueError):
-                        return stderr_b or b""
-                else:
-                    return stderr_b or b""
-
-            # END status handling
-
-            if status != 0:
-                errstr = read_all_from_possibly_closed_stream(p_stderr)
-                _logger.debug("AutoInterrupt wait stderr: %r" % (errstr,))
-                raise GitCommandError(remove_password_if_present(self.args), status, errstr)
-            return status
-
-    # END auto interrupt
-
-    class CatFileContentStream:
-        """Object representing a sized read-only stream returning the contents of
-        an object.
-
-        This behaves like a stream, but counts the data read and simulates an empty
-        stream once our sized content region is empty.
-
-        If not all data are read to the end of the object's lifetime, we read the
-        rest to ensure the underlying stream continues to work.
-        """
-
-        __slots__ = ("_stream", "_nbr", "_size")
-
-        def __init__(self, size: int, stream: IO[bytes]) -> None:
-            self._stream = stream
-            self._size = size
-            self._nbr = 0  # Number of bytes read.
-
-            # Special case: If the object is empty, has null bytes, get the final
-            # newline right away.
-            if size == 0:
-                stream.read(1)
-            # END handle empty streams
-
-        def read(self, size: int = -1) -> bytes:
-            bytes_left = self._size - self._nbr
-            if bytes_left == 0:
-                return b""
-            if size > -1:
-                # Ensure we don't try to read past our limit.
-                size = min(bytes_left, size)
-            else:
-                # They try to read all, make sure it's not more than what remains.
-                size = bytes_left
-            # END check early depletion
-            data = self._stream.read(size)
-            self._nbr += len(data)
-
-            # Check for depletion, read our final byte to make the stream usable by
-            # others.
-            if self._size - self._nbr == 0:
-                self._stream.read(1)  # final newline
-            # END finish reading
-            return data
-
-        def readline(self, size: int = -1) -> bytes:
-            if self._nbr == self._size:
-                return b""
-
-            # Clamp size to lowest allowed value.
-            bytes_left = self._size - self._nbr
-            if size > -1:
-                size = min(bytes_left, size)
-            else:
-                size = bytes_left
-            # END handle size
-
-            data = self._stream.readline(size)
-            self._nbr += len(data)
-
-            # Handle final byte.
-            if self._size - self._nbr == 0:
-                self._stream.read(1)
-            # END finish reading
-
-            return data
-
-        def readlines(self, size: int = -1) -> List[bytes]:
-            if self._nbr == self._size:
-                return []
-
-            # Leave all additional logic to our readline method, we just check the size.
-            out = []
-            nbr = 0
-            while True:
-                line = self.readline()
-                if not line:
-                    break
-                out.append(line)
-                if size > -1:
-                    nbr += len(line)
-                    if nbr > size:
-                        break
-                # END handle size constraint
-            # END readline loop
-            return out
-
-        # skipcq: PYL-E0301
-        def __iter__(self) -> "Git.CatFileContentStream":
-            return self
-
-        def __next__(self) -> bytes:
-            line = self.readline()
-            if not line:
-                raise StopIteration
-
-            return line
-
-        next = __next__
-
-        def __del__(self) -> None:
-            bytes_left = self._size - self._nbr
-            if bytes_left:
-                # Read and discard - seeking is impossible within a stream.
-                # This includes any terminating newline.
-                self._stream.read(bytes_left + 1)
-            # END handle incomplete read
-
-    def __init__(self, working_dir: Union[None, PathLike] = None) -> None:
-        """Initialize this instance with:
-
-        :param working_dir:
-            Git directory we should work in. If ``None``, we always work in the current
-            directory as returned by :func:`os.getcwd`.
-            This is meant to be the working tree directory if available, or the
-            ``.git`` directory in case of bare repositories.
-        """
-        super().__init__()
-        self._working_dir = expand_path(working_dir)
-        self._git_options: Union[List[str], Tuple[str, ...]] = ()
-        self._persistent_git_options: List[str] = []
-
-        # Extra environment variables to pass to git commands
-        self._environment: Dict[str, str] = {}
-
-        # Cached version slots
-        self._version_info: Union[Tuple[int, ...], None] = None
-        self._version_info_token: object = None
-
-        # Cached command slots
-        self.cat_file_header: Union[None, TBD] = None
-        self.cat_file_all: Union[None, TBD] = None
-
-    def __getattribute__(self, name: str) -> Any:
-        if name == "USE_SHELL":
-            _warn_use_shell(False)
-        return super().__getattribute__(name)
-
-    def __getattr__(self, name: str) -> Any:
-        """A convenience method as it allows to call the command as if it was an object.
-
-        :return:
-            Callable object that will execute call :meth:`_call_process` with your
-            arguments.
-        """
-        if name.startswith("_"):
-            return super().__getattribute__(name)
-        return lambda *args, **kwargs: self._call_process(name, *args, **kwargs)
-
-    def set_persistent_git_options(self, **kwargs: Any) -> None:
-        """Specify command line options to the git executable for subsequent
-        subcommand calls.
-
-        :param kwargs:
-            A dict of keyword arguments.
-            These arguments are passed as in :meth:`_call_process`, but will be passed
-            to the git command rather than the subcommand.
-        """
-
-        self._persistent_git_options = self.transform_kwargs(split_single_char_options=True, **kwargs)
-
-    @property
-    def working_dir(self) -> Union[None, PathLike]:
-        """:return: Git directory we are working on"""
-        return self._working_dir
-
-    @property
-    def version_info(self) -> Tuple[int, ...]:
-        """
-        :return: Tuple with integers representing the major, minor and additional
-            version numbers as parsed from :manpage:`git-version(1)`. Up to four fields
-            are used.
-
-            This value is generated on demand and is cached.
-        """
-        # Refreshing is global, but version_info caching is per-instance.
-        refresh_token = self._refresh_token  # Copy token in case of concurrent refresh.
-
-        # Use the cached version if obtained after the most recent refresh.
-        if self._version_info_token is refresh_token:
-            assert self._version_info is not None, "Bug: corrupted token-check state"
-            return self._version_info
-
-        # Run "git version" and parse it.
-        process_version = self._call_process("version")
-        version_string = process_version.split(" ")[2]
-        version_fields = version_string.split(".")[:4]
-        leading_numeric_fields = itertools.takewhile(str.isdigit, version_fields)
-        self._version_info = tuple(map(int, leading_numeric_fields))
-
-        # This value will be considered valid until the next refresh.
-        self._version_info_token = refresh_token
-        return self._version_info
-
-    @overload
-    def execute(
-        self,
-        command: Union[str, Sequence[Any]],
-        *,
-        as_process: Literal[True],
-    ) -> "AutoInterrupt": ...
-
-    @overload
-    def execute(
-        self,
-        command: Union[str, Sequence[Any]],
-        *,
-        as_process: Literal[False] = False,
-        stdout_as_string: Literal[True],
-    ) -> Union[str, Tuple[int, str, str]]: ...
-
-    @overload
-    def execute(
-        self,
-        command: Union[str, Sequence[Any]],
-        *,
-        as_process: Literal[False] = False,
-        stdout_as_string: Literal[False] = False,
-    ) -> Union[bytes, Tuple[int, bytes, str]]: ...
-
-    @overload
-    def execute(
-        self,
-        command: Union[str, Sequence[Any]],
-        *,
-        with_extended_output: Literal[False],
-        as_process: Literal[False],
-        stdout_as_string: Literal[True],
-    ) -> str: ...
-
-    @overload
-    def execute(
-        self,
-        command: Union[str, Sequence[Any]],
-        *,
-        with_extended_output: Literal[False],
-        as_process: Literal[False],
-        stdout_as_string: Literal[False],
-    ) -> bytes: ...
-
-    def execute(
-        self,
-        command: Union[str, Sequence[Any]],
-        istream: Union[None, BinaryIO] = None,
-        with_extended_output: bool = False,
-        with_exceptions: bool = True,
-        as_process: bool = False,
-        output_stream: Union[None, BinaryIO] = None,
-        stdout_as_string: bool = True,
-        kill_after_timeout: Union[None, float] = None,
-        with_stdout: bool = True,
-        universal_newlines: bool = False,
-        shell: Union[None, bool] = None,
-        env: Union[None, Mapping[str, str]] = None,
-        max_chunk_size: int = io.DEFAULT_BUFFER_SIZE,
-        strip_newline_in_stdout: bool = True,
-        **subprocess_kwargs: Any,
-    ) -> Union[str, bytes, Tuple[int, Union[str, bytes], str], AutoInterrupt]:
-        R"""Handle executing the command, and consume and return the returned
-        information (stdout).
-
-        :param command:
-            The command argument list to execute.
-            It should be a sequence of program arguments, or a string. The
-            program to execute is the first item in the args sequence or string.
-
-        :param istream:
-            Standard input filehandle passed to :class:`subprocess.Popen`.
-
-        :param with_extended_output:
-            Whether to return a (status, stdout, stderr) tuple.
-
-        :param with_exceptions:
-            Whether to raise an exception when git returns a non-zero status.
-
-        :param as_process:
-            Whether to return the created process instance directly from which
-            streams can be read on demand. This will render `with_extended_output`
-            and `with_exceptions` ineffective - the caller will have to deal with
-            the details. It is important to note that the process will be placed
-            into an :class:`AutoInterrupt` wrapper that will interrupt the process
-            once it goes out of scope. If you use the command in iterators, you
-            should pass the whole process instance instead of a single stream.
-
-        :param output_stream:
-            If set to a file-like object, data produced by the git command will be
-            copied to the given stream instead of being returned as a string.
-            This feature only has any effect if `as_process` is ``False``.
-
-        :param stdout_as_string:
-            If ``False``, the command's standard output will be bytes. Otherwise, it
-            will be decoded into a string using the default encoding (usually UTF-8).
-            The latter can fail, if the output contains binary data.
-
-        :param kill_after_timeout:
-            Specifies a timeout in seconds for the git command, after which the process
-            should be killed. This will have no effect if `as_process` is set to
-            ``True``. It is set to ``None`` by default and will let the process run
-            until the timeout is explicitly specified. Uses of this feature should be
-            carefully considered, due to the following limitations:
-
-            1. This feature is not supported at all on Windows.
-            2. Effectiveness may vary by operating system. ``ps --ppid`` is used to
-               enumerate child processes, which is available on most GNU/Linux systems
-               but not most others.
-            3. Deeper descendants do not receive signals, though they may sometimes
-               terminate as a consequence of their parent processes being killed.
-            4. `kill_after_timeout` uses ``SIGKILL``, which can have negative side
-               effects on a repository. For example, stale locks in case of
-               :manpage:`git-gc(1)` could render the repository incapable of accepting
-               changes until the lock is manually removed.
-
-        :param with_stdout:
-            If ``True``, default ``True``, we open stdout on the created process.
-
-        :param universal_newlines:
-            If ``True``, pipes will be opened as text, and lines are split at all known
-            line endings.
-
-        :param shell:
-            Whether to invoke commands through a shell
-            (see :class:`Popen(..., shell=True) <subprocess.Popen>`).
-            If this is not ``None``, it overrides :attr:`USE_SHELL`.
-
-            Passing ``shell=True`` to this or any other GitPython function should be
-            avoided, as it is unsafe under most circumstances. This is because it is
-            typically not feasible to fully consider and account for the effect of shell
-            expansions, especially when passing ``shell=True`` to other methods that
-            forward it to :meth:`Git.execute`. Passing ``shell=True`` is also no longer
-            needed (nor useful) to work around any known operating system specific
-            issues.
-
-        :param env:
-            A dictionary of environment variables to be passed to
-            :class:`subprocess.Popen`.
-
-        :param max_chunk_size:
-            Maximum number of bytes in one chunk of data passed to the `output_stream`
-            in one invocation of its ``write()`` method. If the given number is not
-            positive then the default value is used.
-
-        :param strip_newline_in_stdout:
-            Whether to strip the trailing ``\n`` of the command stdout.
-
-        :param subprocess_kwargs:
-            Keyword arguments to be passed to :class:`subprocess.Popen`. Please note
-            that some of the valid kwargs are already set by this method; the ones you
-            specify may not be the same ones.
-
-        :return:
-            * str(output), if `extended_output` is ``False`` (Default)
-            * tuple(int(status), str(stdout), str(stderr)),
-              if `extended_output` is ``True``
-
-            If `output_stream` is ``True``, the stdout value will be your output stream:
-
-            * output_stream, if `extended_output` is ``False``
-            * tuple(int(status), output_stream, str(stderr)),
-              if `extended_output` is ``True``
-
-            Note that git is executed with ``LC_MESSAGES="C"`` to ensure consistent
-            output regardless of system language.
-
-        :raise git.exc.GitCommandError:
-
-        :note:
-            If you add additional keyword arguments to the signature of this method, you
-            must update the ``execute_kwargs`` variable housed in this module.
-        """
-        # Remove password for the command if present.
-        redacted_command = remove_password_if_present(command)
-        if self.GIT_PYTHON_TRACE and (self.GIT_PYTHON_TRACE != "full" or as_process):
-            _logger.info(" ".join(redacted_command))
-
-        # Allow the user to have the command executed in their working dir.
-        try:
-            cwd = self._working_dir or os.getcwd()  # type: Union[None, str]
-            if not os.access(str(cwd), os.X_OK):
-                cwd = None
-        except FileNotFoundError:
-            cwd = None
-
-        # Start the process.
-        inline_env = env
-        env = os.environ.copy()
-        # Attempt to force all output to plain ASCII English, which is what some parsing
-        # code may expect.
-        # According to https://askubuntu.com/a/311796, we are setting LANGUAGE as well
-        # just to be sure.
-        env["LANGUAGE"] = "C"
-        env["LC_ALL"] = "C"
-        env.update(self._environment)
-        if inline_env is not None:
-            env.update(inline_env)
-
-        if sys.platform == "win32":
-            if kill_after_timeout is not None:
-                raise GitCommandError(
-                    redacted_command,
-                    '"kill_after_timeout" feature is not supported on Windows.',
-                )
-            cmd_not_found_exception = OSError
-        else:
-            cmd_not_found_exception = FileNotFoundError
-        # END handle
-
-        stdout_sink = PIPE if with_stdout else getattr(subprocess, "DEVNULL", None) or open(os.devnull, "wb")
-        if shell is None:
-            # Get the value of USE_SHELL with no deprecation warning. Do this without
-            # warnings.catch_warnings, to avoid a race condition with application code
-            # configuring warnings. The value could be looked up in type(self).__dict__
-            # or Git.__dict__, but those can break under some circumstances. This works
-            # the same as self.USE_SHELL in more situations; see Git.__getattribute__.
-            shell = super().__getattribute__("USE_SHELL")
-        _logger.debug(
-            "Popen(%s, cwd=%s, stdin=%s, shell=%s, universal_newlines=%s)",
-            redacted_command,
-            cwd,
-            "<valid stream>" if istream else "None",
-            shell,
-            universal_newlines,
-        )
-        try:
-            proc = safer_popen(
-                command,
-                env=env,
-                cwd=cwd,
-                bufsize=-1,
-                stdin=(istream or DEVNULL),
-                stderr=PIPE,
-                stdout=stdout_sink,
-                shell=shell,
-                universal_newlines=universal_newlines,
-                **subprocess_kwargs,
-            )
-        except cmd_not_found_exception as err:
-            raise GitCommandNotFound(redacted_command, err) from err
-        else:
-            # Replace with a typeguard for Popen[bytes]?
-            proc.stdout = cast(BinaryIO, proc.stdout)
-            proc.stderr = cast(BinaryIO, proc.stderr)
-
-        if as_process:
-            return self.AutoInterrupt(proc, command)
-
-        if sys.platform != "win32" and kill_after_timeout is not None:
-            # Help mypy figure out this is not None even when used inside communicate().
-            timeout = kill_after_timeout
-
-            def kill_process(pid: int) -> None:
-                """Callback to kill a process.
-
-                This callback implementation would be ineffective and unsafe on Windows.
-                """
-                p = Popen(["ps", "--ppid", str(pid)], stdout=PIPE)
-                child_pids = []
-                if p.stdout is not None:
-                    for line in p.stdout:
-                        if len(line.split()) > 0:
-                            local_pid = (line.split())[0]
-                            if local_pid.isdigit():
-                                child_pids.append(int(local_pid))
-                try:
-                    os.kill(pid, signal.SIGKILL)
-                    for child_pid in child_pids:
-                        try:
-                            os.kill(child_pid, signal.SIGKILL)
-                        except OSError:
-                            pass
-                    # Tell the main routine that the process was killed.
-                    kill_check.set()
-                except OSError:
-                    # It is possible that the process gets completed in the duration
-                    # after timeout happens and before we try to kill the process.
-                    pass
-                return
-
-            def communicate() -> Tuple[AnyStr, AnyStr]:
-                watchdog.start()
-                out, err = proc.communicate()
-                watchdog.cancel()
-                if kill_check.is_set():
-                    err = 'Timeout: the command "%s" did not complete in %d ' "secs." % (
-                        " ".join(redacted_command),
-                        timeout,
-                    )
-                    if not universal_newlines:
-                        err = err.encode(defenc)
-                return out, err
-
-            # END helpers
-
-            kill_check = threading.Event()
-            watchdog = threading.Timer(timeout, kill_process, args=(proc.pid,))
-        else:
-            communicate = proc.communicate
-
-        # Wait for the process to return.
-        status = 0
-        stdout_value: Union[str, bytes] = b""
-        stderr_value: Union[str, bytes] = b""
-        newline = "\n" if universal_newlines else b"\n"
-        try:
-            if output_stream is None:
-                stdout_value, stderr_value = communicate()
-                # Strip trailing "\n".
-                if stdout_value.endswith(newline) and strip_newline_in_stdout:  # type: ignore[arg-type]
-                    stdout_value = stdout_value[:-1]
-                if stderr_value.endswith(newline):  # type: ignore[arg-type]
-                    stderr_value = stderr_value[:-1]
-
-                status = proc.returncode
-            else:
-                max_chunk_size = max_chunk_size if max_chunk_size and max_chunk_size > 0 else io.DEFAULT_BUFFER_SIZE
-                stream_copy(proc.stdout, output_stream, max_chunk_size)
-                stdout_value = proc.stdout.read()
-                stderr_value = proc.stderr.read()
-                # Strip trailing "\n".
-                if stderr_value.endswith(newline):  # type: ignore[arg-type]
-                    stderr_value = stderr_value[:-1]
-                status = proc.wait()
-            # END stdout handling
-        finally:
-            proc.stdout.close()
-            proc.stderr.close()
-
-        if self.GIT_PYTHON_TRACE == "full":
-            cmdstr = " ".join(redacted_command)
-
-            def as_text(stdout_value: Union[bytes, str]) -> str:
-                return not output_stream and safe_decode(stdout_value) or "<OUTPUT_STREAM>"
-
-            # END as_text
-
-            if stderr_value:
-                _logger.info(
-                    "%s -> %d; stdout: '%s'; stderr: '%s'",
-                    cmdstr,
-                    status,
-                    as_text(stdout_value),
-                    safe_decode(stderr_value),
-                )
-            elif stdout_value:
-                _logger.info("%s -> %d; stdout: '%s'", cmdstr, status, as_text(stdout_value))
-            else:
-                _logger.info("%s -> %d", cmdstr, status)
-        # END handle debug printing
-
-        if with_exceptions and status != 0:
-            raise GitCommandError(redacted_command, status, stderr_value, stdout_value)
-
-        if isinstance(stdout_value, bytes) and stdout_as_string:  # Could also be output_stream.
-            stdout_value = safe_decode(stdout_value)
-
-        # Allow access to the command's status code.
-        if with_extended_output:
-            return (status, stdout_value, safe_decode(stderr_value))
-        else:
-            return stdout_value
-
-    def environment(self) -> Dict[str, str]:
-        return self._environment
-
-    def update_environment(self, **kwargs: Any) -> Dict[str, Union[str, None]]:
-        """Set environment variables for future git invocations. Return all changed
-        values in a format that can be passed back into this function to revert the
-        changes.
-
-        Examples::
-
-            old_env = self.update_environment(PWD='/tmp')
-            self.update_environment(**old_env)
-
-        :param kwargs:
-            Environment variables to use for git processes.
-
-        :return:
-            Dict that maps environment variables to their old values
-        """
-        old_env = {}
-        for key, value in kwargs.items():
-            # Set value if it is None.
-            if value is not None:
-                old_env[key] = self._environment.get(key)
-                self._environment[key] = value
-            # Remove key from environment if its value is None.
-            elif key in self._environment:
-                old_env[key] = self._environment[key]
-                del self._environment[key]
-        return old_env
-
-    @contextlib.contextmanager
-    def custom_environment(self, **kwargs: Any) -> Iterator[None]:
-        """A context manager around the above :meth:`update_environment` method to
-        restore the environment back to its previous state after operation.
-
-        Examples::
-
-            with self.custom_environment(GIT_SSH='/bin/ssh_wrapper'):
-                repo.remotes.origin.fetch()
-
-        :param kwargs:
-            See :meth:`update_environment`.
-        """
-        old_env = self.update_environment(**kwargs)
-        try:
-            yield
-        finally:
-            self.update_environment(**old_env)
-
-    def transform_kwarg(self, name: str, value: Any, split_single_char_options: bool) -> List[str]:
-        if len(name) == 1:
-            if value is True:
-                return ["-%s" % name]
-            elif value not in (False, None):
-                if split_single_char_options:
-                    return ["-%s" % name, "%s" % value]
-                else:
-                    return ["-%s%s" % (name, value)]
-        else:
-            if value is True:
-                return ["--%s" % dashify(name)]
-            elif value is not False and value is not None:
-                return ["--%s=%s" % (dashify(name), value)]
-        return []
-
-    def transform_kwargs(self, split_single_char_options: bool = True, **kwargs: Any) -> List[str]:
-        """Transform Python-style kwargs into git command line options."""
-        args = []
-        for k, v in kwargs.items():
-            if isinstance(v, (list, tuple)):
-                for value in v:
-                    args += self.transform_kwarg(k, value, split_single_char_options)
-            else:
-                args += self.transform_kwarg(k, v, split_single_char_options)
-        return args
-
-    @classmethod
-    def _unpack_args(cls, arg_list: Sequence[str]) -> List[str]:
-        outlist = []
-        if isinstance(arg_list, (list, tuple)):
-            for arg in arg_list:
-                outlist.extend(cls._unpack_args(arg))
-        else:
-            outlist.append(str(arg_list))
-
-        return outlist
-
-    def __call__(self, **kwargs: Any) -> "Git":
-        """Specify command line options to the git executable for a subcommand call.
-
-        :param kwargs:
-            A dict of keyword arguments.
-            These arguments are passed as in :meth:`_call_process`, but will be passed
-            to the git command rather than the subcommand.
-
-        Examples::
-
-            git(work_tree='/tmp').difftool()
-        """
-        self._git_options = self.transform_kwargs(split_single_char_options=True, **kwargs)
-        return self
-
-    @overload
-    def _call_process(
-        self, method: str, *args: None, **kwargs: None
-    ) -> str: ...  # If no args were given, execute the call with all defaults.
-
-    @overload
-    def _call_process(
-        self,
-        method: str,
-        istream: int,
-        as_process: Literal[True],
-        *args: Any,
-        **kwargs: Any,
-    ) -> "Git.AutoInterrupt": ...
-
-    @overload
-    def _call_process(
-        self, method: str, *args: Any, **kwargs: Any
-    ) -> Union[str, bytes, Tuple[int, Union[str, bytes], str], "Git.AutoInterrupt"]: ...
-
-    def _call_process(
-        self, method: str, *args: Any, **kwargs: Any
-    ) -> Union[str, bytes, Tuple[int, Union[str, bytes], str], "Git.AutoInterrupt"]:
-        """Run the given git command with the specified arguments and return the result
-        as a string.
-
-        :param method:
-            The command. Contained ``_`` characters will be converted to hyphens, such
-            as in ``ls_files`` to call ``ls-files``.
-
-        :param args:
-            The list of arguments. If ``None`` is included, it will be pruned.
-            This allows your commands to call git more conveniently, as ``None`` is
-            realized as non-existent.
-
-        :param kwargs:
-            Contains key-values for the following:
-
-            - The :meth:`execute()` kwds, as listed in ``execute_kwargs``.
-            - "Command options" to be converted by :meth:`transform_kwargs`.
-            - The ``insert_kwargs_after`` key which its value must match one of
-              ``*args``.
-
-            It also contains any command options, to be appended after the matched arg.
-
-        Examples::
-
-            git.rev_list('master', max_count=10, header=True)
-
-        turns into::
-
-            git rev-list max-count 10 --header master
-
-        :return:
-            Same as :meth:`execute`. If no args are given, used :meth:`execute`'s
-            default (especially ``as_process = False``, ``stdout_as_string = True``) and
-            return :class:`str`.
-        """
-        # Handle optional arguments prior to calling transform_kwargs.
-        # Otherwise these'll end up in args, which is bad.
-        exec_kwargs = {k: v for k, v in kwargs.items() if k in execute_kwargs}
-        opts_kwargs = {k: v for k, v in kwargs.items() if k not in execute_kwargs}
-
-        insert_after_this_arg = opts_kwargs.pop("insert_kwargs_after", None)
-
-        # Prepare the argument list.
-
-        opt_args = self.transform_kwargs(**opts_kwargs)
-        ext_args = self._unpack_args([a for a in args if a is not None])
-
-        if insert_after_this_arg is None:
-            args_list = opt_args + ext_args
-        else:
-            try:
-                index = ext_args.index(insert_after_this_arg)
-            except ValueError as err:
-                raise ValueError(
-                    "Couldn't find argument '%s' in args %s to insert cmd options after"
-                    % (insert_after_this_arg, str(ext_args))
-                ) from err
-            # END handle error
-            args_list = ext_args[: index + 1] + opt_args + ext_args[index + 1 :]
-        # END handle opts_kwargs
-
-        call = [self.GIT_PYTHON_GIT_EXECUTABLE]
-
-        # Add persistent git options.
-        call.extend(self._persistent_git_options)
-
-        # Add the git options, then reset to empty to avoid side effects.
-        call.extend(self._git_options)
-        self._git_options = ()
-
-        call.append(dashify(method))
-        call.extend(args_list)
-
-        return self.execute(call, **exec_kwargs)
-
-    def _parse_object_header(self, header_line: str) -> Tuple[str, str, int]:
-        """
-        :param header_line:
-            A line of the form::
-
-                <hex_sha> type_string size_as_int
-
-        :return:
-            (hex_sha, type_string, size_as_int)
-
-        :raise ValueError:
-            If the header contains indication for an error due to incorrect input sha.
-        """
-        tokens = header_line.split()
-        if len(tokens) != 3:
-            if not tokens:
-                err_msg = (
-                    f"SHA is empty, possible dubious ownership in the repository "
-                    f"""at {self._working_dir}.\n            If this is unintended run:\n\n         """
-                    f"""             "git config --global --add safe.directory {self._working_dir}" """
-                )
-                raise ValueError(err_msg)
-            else:
-                raise ValueError("SHA %s could not be resolved, git returned: %r" % (tokens[0], header_line.strip()))
-            # END handle actual return value
-        # END error handling
-
-        if len(tokens[0]) != 40:
-            raise ValueError("Failed to parse header: %r" % header_line)
-        return (tokens[0], tokens[1], int(tokens[2]))
-
-    def _prepare_ref(self, ref: AnyStr) -> bytes:
-        # Required for command to separate refs on stdin, as bytes.
-        if isinstance(ref, bytes):
-            # Assume 40 bytes hexsha - bin-to-ascii for some reason returns bytes, not text.
-            refstr: str = ref.decode("ascii")
-        elif not isinstance(ref, str):
-            refstr = str(ref)  # Could be ref-object.
-        else:
-            refstr = ref
-
-        if not refstr.endswith("\n"):
-            refstr += "\n"
-        return refstr.encode(defenc)
-
-    def _get_persistent_cmd(self, attr_name: str, cmd_name: str, *args: Any, **kwargs: Any) -> "Git.AutoInterrupt":
-        cur_val = getattr(self, attr_name)
-        if cur_val is not None:
-            return cur_val
-
-        options = {"istream": PIPE, "as_process": True}
-        options.update(kwargs)
-
-        cmd = self._call_process(cmd_name, *args, **options)
-        setattr(self, attr_name, cmd)
-        cmd = cast("Git.AutoInterrupt", cmd)
-        return cmd
-
-    def __get_object_header(self, cmd: "Git.AutoInterrupt", ref: AnyStr) -> Tuple[str, str, int]:
-        if cmd.stdin and cmd.stdout:
-            cmd.stdin.write(self._prepare_ref(ref))
-            cmd.stdin.flush()
-            return self._parse_object_header(cmd.stdout.readline())
-        else:
-            raise ValueError("cmd stdin was empty")
-
-    def get_object_header(self, ref: str) -> Tuple[str, str, int]:
-        """Use this method to quickly examine the type and size of the object behind the
-        given ref.
-
-        :note:
-            The method will only suffer from the costs of command invocation once and
-            reuses the command in subsequent calls.
-
-        :return:
-            (hexsha, type_string, size_as_int)
-        """
-        cmd = self._get_persistent_cmd("cat_file_header", "cat_file", batch_check=True)
-        return self.__get_object_header(cmd, ref)
-
-    def get_object_data(self, ref: str) -> Tuple[str, str, int, bytes]:
-        """Similar to :meth:`get_object_header`, but returns object data as well.
-
-        :return:
-            (hexsha, type_string, size_as_int, data_string)
-
-        :note:
-            Not threadsafe.
-        """
-        hexsha, typename, size, stream = self.stream_object_data(ref)
-        data = stream.read(size)
-        del stream
-        return (hexsha, typename, size, data)
-
-    def stream_object_data(self, ref: str) -> Tuple[str, str, int, "Git.CatFileContentStream"]:
-        """Similar to :meth:`get_object_data`, but returns the data as a stream.
-
-        :return:
-            (hexsha, type_string, size_as_int, stream)
-
-        :note:
-            This method is not threadsafe. You need one independent :class:`Git`
-            instance per thread to be safe!
-        """
-        cmd = self._get_persistent_cmd("cat_file_all", "cat_file", batch=True)
-        hexsha, typename, size = self.__get_object_header(cmd, ref)
-        cmd_stdout = cmd.stdout if cmd.stdout is not None else io.BytesIO()
-        return (hexsha, typename, size, self.CatFileContentStream(size, cmd_stdout))
-
-    def clear_cache(self) -> "Git":
-        """Clear all kinds of internal caches to release resources.
-
-        Currently persistent commands will be interrupted.
-
-        :return:
-            self
-        """
-        for cmd in (self.cat_file_all, self.cat_file_header):
-            if cmd:
-                cmd.__del__()
-
-        self.cat_file_all = None
-        self.cat_file_header = None
-        return self

ILYA/Lib/site-packages/git/compat.py

@@ -1,165 +0,0 @@
-# Copyright (C) 2008, 2009 Michael Trier ([email protected]) and contributors
-#
-# This module is part of GitPython and is released under the
-# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
-
-"""Utilities to help provide compatibility with Python 3.
-
-This module exists for historical reasons. Code outside GitPython may make use of public
-members of this module, but is unlikely to benefit from doing so. GitPython continues to
-use some of these utilities, in some cases for compatibility across different platforms.
-"""
-
-import locale
-import os
-import sys
-import warnings
-
-from gitdb.utils.encoding import force_bytes, force_text  # noqa: F401
-
-# typing --------------------------------------------------------------------
-
-from typing import (
-    Any,  # noqa: F401
-    AnyStr,
-    Dict,  # noqa: F401
-    IO,  # noqa: F401
-    List,
-    Optional,
-    TYPE_CHECKING,
-    Tuple,  # noqa: F401
-    Type,  # noqa: F401
-    Union,
-    overload,
-)
-
-# ---------------------------------------------------------------------------
-
-
-_deprecated_platform_aliases = {
-    "is_win": os.name == "nt",
-    "is_posix": os.name == "posix",
-    "is_darwin": sys.platform == "darwin",
-}
-
-
-def _getattr(name: str) -> Any:
-    try:
-        value = _deprecated_platform_aliases[name]
-    except KeyError:
-        raise AttributeError(f"module {__name__!r} has no attribute {name!r}") from None
-
-    warnings.warn(
-        f"{__name__}.{name} and other is_<platform> aliases are deprecated. "
-        "Write the desired os.name or sys.platform check explicitly instead.",
-        DeprecationWarning,
-        stacklevel=2,
-    )
-    return value
-
-
-if not TYPE_CHECKING:  # Preserve static checking for undefined/misspelled attributes.
-    __getattr__ = _getattr
-
-
-def __dir__() -> List[str]:
-    return [*globals(), *_deprecated_platform_aliases]
-
-
-is_win: bool
-"""Deprecated alias for ``os.name == "nt"`` to check for native Windows.
-
-This is deprecated because it is clearer to write out :attr:`os.name` or
-:attr:`sys.platform` checks explicitly, especially in cases where it matters which is
-used.
-
-:note:
-    ``is_win`` is ``False`` on Cygwin, but is often wrongly assumed ``True``. To detect
-    Cygwin, use ``sys.platform == "cygwin"``.
-"""
-
-is_posix: bool
-"""Deprecated alias for ``os.name == "posix"`` to check for Unix-like ("POSIX") systems.
-
-This is deprecated because it clearer to write out :attr:`os.name` or
-:attr:`sys.platform` checks explicitly, especially in cases where it matters which is
-used.
-
-:note:
-    For POSIX systems, more detailed information is available in :attr:`sys.platform`,
-    while :attr:`os.name` is always ``"posix"`` on such systems, including macOS
-    (Darwin).
-"""
-
-is_darwin: bool
-"""Deprecated alias for ``sys.platform == "darwin"`` to check for macOS (Darwin).
-
-This is deprecated because it clearer to write out :attr:`os.name` or
-:attr:`sys.platform` checks explicitly.
-
-:note:
-    For macOS (Darwin), ``os.name == "posix"`` as in other Unix-like systems, while
-    ``sys.platform == "darwin"``.
-"""
-
-defenc = sys.getfilesystemencoding()
-"""The encoding used to convert between Unicode and bytes filenames."""
-
-
-@overload
-def safe_decode(s: None) -> None: ...
-
-
-@overload
-def safe_decode(s: AnyStr) -> str: ...
-
-
-def safe_decode(s: Union[AnyStr, None]) -> Optional[str]:
-    """Safely decode a binary string to Unicode."""
-    if isinstance(s, str):
-        return s
-    elif isinstance(s, bytes):
-        return s.decode(defenc, "surrogateescape")
-    elif s is None:
-        return None
-    else:
-        raise TypeError("Expected bytes or text, but got %r" % (s,))
-
-
-@overload
-def safe_encode(s: None) -> None: ...
-
-
-@overload
-def safe_encode(s: AnyStr) -> bytes: ...
-
-
-def safe_encode(s: Optional[AnyStr]) -> Optional[bytes]:
-    """Safely encode a binary string to Unicode."""
-    if isinstance(s, str):
-        return s.encode(defenc)
-    elif isinstance(s, bytes):
-        return s
-    elif s is None:
-        return None
-    else:
-        raise TypeError("Expected bytes or text, but got %r" % (s,))
-
-
-@overload
-def win_encode(s: None) -> None: ...
-
-
-@overload
-def win_encode(s: AnyStr) -> bytes: ...
-
-
-def win_encode(s: Optional[AnyStr]) -> Optional[bytes]:
-    """Encode Unicode strings for process arguments on Windows."""
-    if isinstance(s, str):
-        return s.encode(locale.getpreferredencoding(False))
-    elif isinstance(s, bytes):
-        return s
-    elif s is not None:
-        raise TypeError("Expected bytes or text, but got %r" % (s,))
-    return None

ILYA/Lib/site-packages/git/config.py

@@ -1,944 +0,0 @@
-# Copyright (C) 2008, 2009 Michael Trier ([email protected]) and contributors
-#
-# This module is part of GitPython and is released under the
-# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
-
-"""Parser for reading and writing configuration files."""
-
-__all__ = ["GitConfigParser", "SectionConstraint"]
-
-import abc
-import configparser as cp
-import fnmatch
-from functools import wraps
-import inspect
-from io import BufferedReader, IOBase
-import logging
-import os
-import os.path as osp
-import re
-import sys
-
-from git.compat import defenc, force_text
-from git.util import LockFile
-
-# typing-------------------------------------------------------
-
-from typing import (
-    Any,
-    Callable,
-    Generic,
-    IO,
-    List,
-    Dict,
-    Sequence,
-    TYPE_CHECKING,
-    Tuple,
-    TypeVar,
-    Union,
-    cast,
-)
-
-from git.types import Lit_config_levels, ConfigLevels_Tup, PathLike, assert_never, _T
-
-if TYPE_CHECKING:
-    from io import BytesIO
-
-    from git.repo.base import Repo
-
-T_ConfigParser = TypeVar("T_ConfigParser", bound="GitConfigParser")
-T_OMD_value = TypeVar("T_OMD_value", str, bytes, int, float, bool)
-
-if sys.version_info[:3] < (3, 7, 2):
-    # typing.Ordereddict not added until Python 3.7.2.
-    from collections import OrderedDict
-
-    OrderedDict_OMD = OrderedDict
-else:
-    from typing import OrderedDict
-
-    OrderedDict_OMD = OrderedDict[str, List[T_OMD_value]]  # type: ignore[assignment, misc]
-
-# -------------------------------------------------------------
-
-_logger = logging.getLogger(__name__)
-
-CONFIG_LEVELS: ConfigLevels_Tup = ("system", "user", "global", "repository")
-"""The configuration level of a configuration file."""
-
-CONDITIONAL_INCLUDE_REGEXP = re.compile(r"(?<=includeIf )\"(gitdir|gitdir/i|onbranch):(.+)\"")
-"""Section pattern to detect conditional includes.
-
-See: https://git-scm.com/docs/git-config#_conditional_includes
-"""
-
-
-class MetaParserBuilder(abc.ABCMeta):  # noqa: B024
-    """Utility class wrapping base-class methods into decorators that assure read-only
-    properties."""
-
-    def __new__(cls, name: str, bases: Tuple, clsdict: Dict[str, Any]) -> "MetaParserBuilder":
-        """Equip all base-class methods with a needs_values decorator, and all non-const
-        methods with a :func:`set_dirty_and_flush_changes` decorator in addition to
-        that.
-        """
-        kmm = "_mutating_methods_"
-        if kmm in clsdict:
-            mutating_methods = clsdict[kmm]
-            for base in bases:
-                methods = (t for t in inspect.getmembers(base, inspect.isroutine) if not t[0].startswith("_"))
-                for name, method in methods:
-                    if name in clsdict:
-                        continue
-                    method_with_values = needs_values(method)
-                    if name in mutating_methods:
-                        method_with_values = set_dirty_and_flush_changes(method_with_values)
-                    # END mutating methods handling
-
-                    clsdict[name] = method_with_values
-                # END for each name/method pair
-            # END for each base
-        # END if mutating methods configuration is set
-
-        new_type = super().__new__(cls, name, bases, clsdict)
-        return new_type
-
-
-def needs_values(func: Callable[..., _T]) -> Callable[..., _T]:
-    """Return a method for ensuring we read values (on demand) before we try to access
-    them."""
-
-    @wraps(func)
-    def assure_data_present(self: "GitConfigParser", *args: Any, **kwargs: Any) -> _T:
-        self.read()
-        return func(self, *args, **kwargs)
-
-    # END wrapper method
-    return assure_data_present
-
-
-def set_dirty_and_flush_changes(non_const_func: Callable[..., _T]) -> Callable[..., _T]:
-    """Return a method that checks whether given non constant function may be called.
-
-    If so, the instance will be set dirty. Additionally, we flush the changes right to
-    disk.
-    """
-
-    def flush_changes(self: "GitConfigParser", *args: Any, **kwargs: Any) -> _T:
-        rval = non_const_func(self, *args, **kwargs)
-        self._dirty = True
-        self.write()
-        return rval
-
-    # END wrapper method
-    flush_changes.__name__ = non_const_func.__name__
-    return flush_changes
-
-
-class SectionConstraint(Generic[T_ConfigParser]):
-    """Constrains a ConfigParser to only option commands which are constrained to
-    always use the section we have been initialized with.
-
-    It supports all ConfigParser methods that operate on an option.
-
-    :note:
-        If used as a context manager, will release the wrapped ConfigParser.
-    """
-
-    __slots__ = ("_config", "_section_name")
-
-    _valid_attrs_ = (
-        "get_value",
-        "set_value",
-        "get",
-        "set",
-        "getint",
-        "getfloat",
-        "getboolean",
-        "has_option",
-        "remove_section",
-        "remove_option",
-        "options",
-    )
-
-    def __init__(self, config: T_ConfigParser, section: str) -> None:
-        self._config = config
-        self._section_name = section
-
-    def __del__(self) -> None:
-        # Yes, for some reason, we have to call it explicitly for it to work in PY3 !
-        # Apparently __del__ doesn't get call anymore if refcount becomes 0
-        # Ridiculous ... .
-        self._config.release()
-
-    def __getattr__(self, attr: str) -> Any:
-        if attr in self._valid_attrs_:
-            return lambda *args, **kwargs: self._call_config(attr, *args, **kwargs)
-        return super().__getattribute__(attr)
-
-    def _call_config(self, method: str, *args: Any, **kwargs: Any) -> Any:
-        """Call the configuration at the given method which must take a section name as
-        first argument."""
-        return getattr(self._config, method)(self._section_name, *args, **kwargs)
-
-    @property
-    def config(self) -> T_ConfigParser:
-        """return: ConfigParser instance we constrain"""
-        return self._config
-
-    def release(self) -> None:
-        """Equivalent to :meth:`GitConfigParser.release`, which is called on our
-        underlying parser instance."""
-        return self._config.release()
-
-    def __enter__(self) -> "SectionConstraint[T_ConfigParser]":
-        self._config.__enter__()
-        return self
-
-    def __exit__(self, exception_type: str, exception_value: str, traceback: str) -> None:
-        self._config.__exit__(exception_type, exception_value, traceback)
-
-
-class _OMD(OrderedDict_OMD):
-    """Ordered multi-dict."""
-
-    def __setitem__(self, key: str, value: _T) -> None:
-        super().__setitem__(key, [value])
-
-    def add(self, key: str, value: Any) -> None:
-        if key not in self:
-            super().__setitem__(key, [value])
-            return
-
-        super().__getitem__(key).append(value)
-
-    def setall(self, key: str, values: List[_T]) -> None:
-        super().__setitem__(key, values)
-
-    def __getitem__(self, key: str) -> Any:
-        return super().__getitem__(key)[-1]
-
-    def getlast(self, key: str) -> Any:
-        return super().__getitem__(key)[-1]
-
-    def setlast(self, key: str, value: Any) -> None:
-        if key not in self:
-            super().__setitem__(key, [value])
-            return
-
-        prior = super().__getitem__(key)
-        prior[-1] = value
-
-    def get(self, key: str, default: Union[_T, None] = None) -> Union[_T, None]:
-        return super().get(key, [default])[-1]
-
-    def getall(self, key: str) -> List[_T]:
-        return super().__getitem__(key)
-
-    def items(self) -> List[Tuple[str, _T]]:  # type: ignore[override]
-        """List of (key, last value for key)."""
-        return [(k, self[k]) for k in self]
-
-    def items_all(self) -> List[Tuple[str, List[_T]]]:
-        """List of (key, list of values for key)."""
-        return [(k, self.getall(k)) for k in self]
-
-
-def get_config_path(config_level: Lit_config_levels) -> str:
-    # We do not support an absolute path of the gitconfig on Windows.
-    # Use the global config instead.
-    if sys.platform == "win32" and config_level == "system":
-        config_level = "global"
-
-    if config_level == "system":
-        return "/etc/gitconfig"
-    elif config_level == "user":
-        config_home = os.environ.get("XDG_CONFIG_HOME") or osp.join(os.environ.get("HOME", "~"), ".config")
-        return osp.normpath(osp.expanduser(osp.join(config_home, "git", "config")))
-    elif config_level == "global":
-        return osp.normpath(osp.expanduser("~/.gitconfig"))
-    elif config_level == "repository":
-        raise ValueError("No repo to get repository configuration from. Use Repo._get_config_path")
-    else:
-        # Should not reach here. Will raise ValueError if does. Static typing will warn
-        # about missing elifs.
-        assert_never(  # type: ignore[unreachable]
-            config_level,
-            ValueError(f"Invalid configuration level: {config_level!r}"),
-        )
-
-
-class GitConfigParser(cp.RawConfigParser, metaclass=MetaParserBuilder):
-    """Implements specifics required to read git style configuration files.
-
-    This variation behaves much like the :manpage:`git-config(1)` command, such that the
-    configuration will be read on demand based on the filepath given during
-    initialization.
-
-    The changes will automatically be written once the instance goes out of scope, but
-    can be triggered manually as well.
-
-    The configuration file will be locked if you intend to change values preventing
-    other instances to write concurrently.
-
-    :note:
-        The config is case-sensitive even when queried, hence section and option names
-        must match perfectly.
-
-    :note:
-        If used as a context manager, this will release the locked file.
-    """
-
-    # { Configuration
-    t_lock = LockFile
-    """The lock type determines the type of lock to use in new configuration readers.
-
-    They must be compatible to the :class:`~git.util.LockFile` interface.
-    A suitable alternative would be the :class:`~git.util.BlockingLockFile`.
-    """
-
-    re_comment = re.compile(r"^\s*[#;]")
-    # } END configuration
-
-    optvalueonly_source = r"\s*(?P<option>[^:=\s][^:=]*)"
-
-    OPTVALUEONLY = re.compile(optvalueonly_source)
-
-    OPTCRE = re.compile(optvalueonly_source + r"\s*(?P<vi>[:=])\s*" + r"(?P<value>.*)$")
-
-    del optvalueonly_source
-
-    _mutating_methods_ = ("add_section", "remove_section", "remove_option", "set")
-    """Names of :class:`~configparser.RawConfigParser` methods able to change the
-    instance."""
-
-    def __init__(
-        self,
-        file_or_files: Union[None, PathLike, "BytesIO", Sequence[Union[PathLike, "BytesIO"]]] = None,
-        read_only: bool = True,
-        merge_includes: bool = True,
-        config_level: Union[Lit_config_levels, None] = None,
-        repo: Union["Repo", None] = None,
-    ) -> None:
-        """Initialize a configuration reader to read the given `file_or_files` and to
-        possibly allow changes to it by setting `read_only` False.
-
-        :param file_or_files:
-            A file path or file object, or a sequence of possibly more than one of them.
-
-        :param read_only:
-            If ``True``, the ConfigParser may only read the data, but not change it.
-            If ``False``, only a single file path or file object may be given. We will
-            write back the changes when they happen, or when the ConfigParser is
-            released. This will not happen if other configuration files have been
-            included.
-
-        :param merge_includes:
-            If ``True``, we will read files mentioned in ``[include]`` sections and
-            merge their contents into ours. This makes it impossible to write back an
-            individual configuration file. Thus, if you want to modify a single
-            configuration file, turn this off to leave the original dataset unaltered
-            when reading it.
-
-        :param repo:
-            Reference to repository to use if ``[includeIf]`` sections are found in
-            configuration files.
-        """
-        cp.RawConfigParser.__init__(self, dict_type=_OMD)
-        self._dict: Callable[..., _OMD]
-        self._defaults: _OMD
-        self._sections: _OMD
-
-        # Used in Python 3. Needs to stay in sync with sections for underlying
-        # implementation to work.
-        if not hasattr(self, "_proxies"):
-            self._proxies = self._dict()
-
-        if file_or_files is not None:
-            self._file_or_files: Union[PathLike, "BytesIO", Sequence[Union[PathLike, "BytesIO"]]] = file_or_files
-        else:
-            if config_level is None:
-                if read_only:
-                    self._file_or_files = [
-                        get_config_path(cast(Lit_config_levels, f)) for f in CONFIG_LEVELS if f != "repository"
-                    ]
-                else:
-                    raise ValueError("No configuration level or configuration files specified")
-            else:
-                self._file_or_files = [get_config_path(config_level)]
-
-        self._read_only = read_only
-        self._dirty = False
-        self._is_initialized = False
-        self._merge_includes = merge_includes
-        self._repo = repo
-        self._lock: Union["LockFile", None] = None
-        self._acquire_lock()
-
-    def _acquire_lock(self) -> None:
-        if not self._read_only:
-            if not self._lock:
-                if isinstance(self._file_or_files, (str, os.PathLike)):
-                    file_or_files = self._file_or_files
-                elif isinstance(self._file_or_files, (tuple, list, Sequence)):
-                    raise ValueError(
-                        "Write-ConfigParsers can operate on a single file only, multiple files have been passed"
-                    )
-                else:
-                    file_or_files = self._file_or_files.name
-
-                # END get filename from handle/stream
-                # Initialize lock base - we want to write.
-                self._lock = self.t_lock(file_or_files)
-            # END lock check
-
-            self._lock._obtain_lock()
-        # END read-only check
-
-    def __del__(self) -> None:
-        """Write pending changes if required and release locks."""
-        # NOTE: Only consistent in Python 2.
-        self.release()
-
-    def __enter__(self) -> "GitConfigParser":
-        self._acquire_lock()
-        return self
-
-    def __exit__(self, *args: Any) -> None:
-        self.release()
-
-    def release(self) -> None:
-        """Flush changes and release the configuration write lock. This instance must
-        not be used anymore afterwards.
-
-        In Python 3, it's required to explicitly release locks and flush changes, as
-        ``__del__`` is not called deterministically anymore.
-        """
-        # Checking for the lock here makes sure we do not raise during write()
-        # in case an invalid parser was created who could not get a lock.
-        if self.read_only or (self._lock and not self._lock._has_lock()):
-            return
-
-        try:
-            self.write()
-        except IOError:
-            _logger.error("Exception during destruction of GitConfigParser", exc_info=True)
-        except ReferenceError:
-            # This happens in Python 3... and usually means that some state cannot be
-            # written as the sections dict cannot be iterated. This usually happens when
-            # the interpreter is shutting down. Can it be fixed?
-            pass
-        finally:
-            if self._lock is not None:
-                self._lock._release_lock()
-
-    def optionxform(self, optionstr: str) -> str:
-        """Do not transform options in any way when writing."""
-        return optionstr
-
-    def _read(self, fp: Union[BufferedReader, IO[bytes]], fpname: str) -> None:
-        """Originally a direct copy of the Python 2.4 version of
-        :meth:`RawConfigParser._read <configparser.RawConfigParser._read>`, to ensure it
-        uses ordered dicts.
-
-        The ordering bug was fixed in Python 2.4, and dict itself keeps ordering since
-        Python 3.7. This has some other changes, especially that it ignores initial
-        whitespace, since git uses tabs. (Big comments are removed to be more compact.)
-        """
-        cursect = None  # None, or a dictionary.
-        optname = None
-        lineno = 0
-        is_multi_line = False
-        e = None  # None, or an exception.
-
-        def string_decode(v: str) -> str:
-            if v[-1] == "\\":
-                v = v[:-1]
-            # END cut trailing escapes to prevent decode error
-
-            return v.encode(defenc).decode("unicode_escape")
-
-        # END string_decode
-
-        while True:
-            # We assume to read binary!
-            line = fp.readline().decode(defenc)
-            if not line:
-                break
-            lineno = lineno + 1
-            # Comment or blank line?
-            if line.strip() == "" or self.re_comment.match(line):
-                continue
-            if line.split(None, 1)[0].lower() == "rem" and line[0] in "rR":
-                # No leading whitespace.
-                continue
-
-            # Is it a section header?
-            mo = self.SECTCRE.match(line.strip())
-            if not is_multi_line and mo:
-                sectname: str = mo.group("header").strip()
-                if sectname in self._sections:
-                    cursect = self._sections[sectname]
-                elif sectname == cp.DEFAULTSECT:
-                    cursect = self._defaults
-                else:
-                    cursect = self._dict((("__name__", sectname),))
-                    self._sections[sectname] = cursect
-                    self._proxies[sectname] = None
-                # So sections can't start with a continuation line.
-                optname = None
-            # No section header in the file?
-            elif cursect is None:
-                raise cp.MissingSectionHeaderError(fpname, lineno, line)
-            # An option line?
-            elif not is_multi_line:
-                mo = self.OPTCRE.match(line)
-                if mo:
-                    # We might just have handled the last line, which could contain a quotation we want to remove.
-                    optname, vi, optval = mo.group("option", "vi", "value")
-                    if vi in ("=", ":") and ";" in optval and not optval.strip().startswith('"'):
-                        pos = optval.find(";")
-                        if pos != -1 and optval[pos - 1].isspace():
-                            optval = optval[:pos]
-                    optval = optval.strip()
-                    if optval == '""':
-                        optval = ""
-                    # END handle empty string
-                    optname = self.optionxform(optname.rstrip())
-                    if len(optval) > 1 and optval[0] == '"' and optval[-1] != '"':
-                        is_multi_line = True
-                        optval = string_decode(optval[1:])
-                    # END handle multi-line
-                    # Preserves multiple values for duplicate optnames.
-                    cursect.add(optname, optval)
-                else:
-                    # Check if it's an option with no value - it's just ignored by git.
-                    if not self.OPTVALUEONLY.match(line):
-                        if not e:
-                            e = cp.ParsingError(fpname)
-                        e.append(lineno, repr(line))
-                    continue
-            else:
-                line = line.rstrip()
-                if line.endswith('"'):
-                    is_multi_line = False
-                    line = line[:-1]
-                # END handle quotations
-                optval = cursect.getlast(optname)
-                cursect.setlast(optname, optval + string_decode(line))
-            # END parse section or option
-        # END while reading
-
-        # If any parsing errors occurred, raise an exception.
-        if e:
-            raise e
-
-    def _has_includes(self) -> Union[bool, int]:
-        return self._merge_includes and len(self._included_paths())
-
-    def _included_paths(self) -> List[Tuple[str, str]]:
-        """List all paths that must be included to configuration.
-
-        :return:
-            The list of paths, where each path is a tuple of (option, value).
-        """
-        paths = []
-
-        for section in self.sections():
-            if section == "include":
-                paths += self.items(section)
-
-            match = CONDITIONAL_INCLUDE_REGEXP.search(section)
-            if match is None or self._repo is None:
-                continue
-
-            keyword = match.group(1)
-            value = match.group(2).strip()
-
-            if keyword in ["gitdir", "gitdir/i"]:
-                value = osp.expanduser(value)
-
-                if not any(value.startswith(s) for s in ["./", "/"]):
-                    value = "**/" + value
-                if value.endswith("/"):
-                    value += "**"
-
-                # Ensure that glob is always case insensitive if required.
-                if keyword.endswith("/i"):
-                    value = re.sub(
-                        r"[a-zA-Z]",
-                        lambda m: "[{}{}]".format(m.group().lower(), m.group().upper()),
-                        value,
-                    )
-                if self._repo.git_dir:
-                    if fnmatch.fnmatchcase(str(self._repo.git_dir), value):
-                        paths += self.items(section)
-
-            elif keyword == "onbranch":
-                try:
-                    branch_name = self._repo.active_branch.name
-                except TypeError:
-                    # Ignore section if active branch cannot be retrieved.
-                    continue
-
-                if fnmatch.fnmatchcase(branch_name, value):
-                    paths += self.items(section)
-
-        return paths
-
-    def read(self) -> None:  # type: ignore[override]
-        """Read the data stored in the files we have been initialized with.
-
-        This will ignore files that cannot be read, possibly leaving an empty
-        configuration.
-
-        :raise IOError:
-            If a file cannot be handled.
-        """
-        if self._is_initialized:
-            return
-        self._is_initialized = True
-
-        files_to_read: List[Union[PathLike, IO]] = [""]
-        if isinstance(self._file_or_files, (str, os.PathLike)):
-            # For str or Path, as str is a type of Sequence.
-            files_to_read = [self._file_or_files]
-        elif not isinstance(self._file_or_files, (tuple, list, Sequence)):
-            # Could merge with above isinstance once runtime type known.
-            files_to_read = [self._file_or_files]
-        else:  # For lists or tuples.
-            files_to_read = list(self._file_or_files)
-        # END ensure we have a copy of the paths to handle
-
-        seen = set(files_to_read)
-        num_read_include_files = 0
-        while files_to_read:
-            file_path = files_to_read.pop(0)
-            file_ok = False
-
-            if hasattr(file_path, "seek"):
-                # Must be a file-object.
-                # TODO: Replace cast with assert to narrow type, once sure.
-                file_path = cast(IO[bytes], file_path)
-                self._read(file_path, file_path.name)
-            else:
-                # Assume a path if it is not a file-object.
-                file_path = cast(PathLike, file_path)
-                try:
-                    with open(file_path, "rb") as fp:
-                        file_ok = True
-                        self._read(fp, fp.name)
-                except IOError:
-                    continue
-
-            # Read includes and append those that we didn't handle yet. We expect all
-            # paths to be normalized and absolute (and will ensure that is the case).
-            if self._has_includes():
-                for _, include_path in self._included_paths():
-                    if include_path.startswith("~"):
-                        include_path = osp.expanduser(include_path)
-                    if not osp.isabs(include_path):
-                        if not file_ok:
-                            continue
-                        # END ignore relative paths if we don't know the configuration file path
-                        file_path = cast(PathLike, file_path)
-                        assert osp.isabs(file_path), "Need absolute paths to be sure our cycle checks will work"
-                        include_path = osp.join(osp.dirname(file_path), include_path)
-                    # END make include path absolute
-                    include_path = osp.normpath(include_path)
-                    if include_path in seen or not os.access(include_path, os.R_OK):
-                        continue
-                    seen.add(include_path)
-                    # Insert included file to the top to be considered first.
-                    files_to_read.insert(0, include_path)
-                    num_read_include_files += 1
-                # END each include path in configuration file
-            # END handle includes
-        # END for each file object to read
-
-        # If there was no file included, we can safely write back (potentially) the
-        # configuration file without altering its meaning.
-        if num_read_include_files == 0:
-            self._merge_includes = False
-
-    def _write(self, fp: IO) -> None:
-        """Write an .ini-format representation of the configuration state in
-        git compatible format."""
-
-        def write_section(name: str, section_dict: _OMD) -> None:
-            fp.write(("[%s]\n" % name).encode(defenc))
-
-            values: Sequence[str]  # Runtime only gets str in tests, but should be whatever _OMD stores.
-            v: str
-            for key, values in section_dict.items_all():
-                if key == "__name__":
-                    continue
-
-                for v in values:
-                    fp.write(("\t%s = %s\n" % (key, self._value_to_string(v).replace("\n", "\n\t"))).encode(defenc))
-                # END if key is not __name__
-
-        # END section writing
-
-        if self._defaults:
-            write_section(cp.DEFAULTSECT, self._defaults)
-        value: _OMD
-
-        for name, value in self._sections.items():
-            write_section(name, value)
-
-    def items(self, section_name: str) -> List[Tuple[str, str]]:  # type: ignore[override]
-        """:return: list((option, value), ...) pairs of all items in the given section"""
-        return [(k, v) for k, v in super().items(section_name) if k != "__name__"]
-
-    def items_all(self, section_name: str) -> List[Tuple[str, List[str]]]:
-        """:return: list((option, [values...]), ...) pairs of all items in the given section"""
-        rv = _OMD(self._defaults)
-
-        for k, vs in self._sections[section_name].items_all():
-            if k == "__name__":
-                continue
-
-            if k in rv and rv.getall(k) == vs:
-                continue
-
-            for v in vs:
-                rv.add(k, v)
-
-        return rv.items_all()
-
-    @needs_values
-    def write(self) -> None:
-        """Write changes to our file, if there are changes at all.
-
-        :raise IOError:
-            If this is a read-only writer instance or if we could not obtain a file
-            lock.
-        """
-        self._assure_writable("write")
-        if not self._dirty:
-            return
-
-        if isinstance(self._file_or_files, (list, tuple)):
-            raise AssertionError(
-                "Cannot write back if there is not exactly a single file to write to, have %i files"
-                % len(self._file_or_files)
-            )
-        # END assert multiple files
-
-        if self._has_includes():
-            _logger.debug(
-                "Skipping write-back of configuration file as include files were merged in."
-                + "Set merge_includes=False to prevent this."
-            )
-            return
-        # END stop if we have include files
-
-        fp = self._file_or_files
-
-        # We have a physical file on disk, so get a lock.
-        is_file_lock = isinstance(fp, (str, os.PathLike, IOBase))  # TODO: Use PathLike (having dropped 3.5).
-        if is_file_lock and self._lock is not None:  # Else raise error?
-            self._lock._obtain_lock()
-
-        if not hasattr(fp, "seek"):
-            fp = cast(PathLike, fp)
-            with open(fp, "wb") as fp_open:
-                self._write(fp_open)
-        else:
-            fp = cast("BytesIO", fp)
-            fp.seek(0)
-            # Make sure we do not overwrite into an existing file.
-            if hasattr(fp, "truncate"):
-                fp.truncate()
-            self._write(fp)
-
-    def _assure_writable(self, method_name: str) -> None:
-        if self.read_only:
-            raise IOError("Cannot execute non-constant method %s.%s" % (self, method_name))
-
-    def add_section(self, section: str) -> None:
-        """Assures added options will stay in order."""
-        return super().add_section(section)
-
-    @property
-    def read_only(self) -> bool:
-        """:return: ``True`` if this instance may change the configuration file"""
-        return self._read_only
-
-    # FIXME: Figure out if default or return type can really include bool.
-    def get_value(
-        self,
-        section: str,
-        option: str,
-        default: Union[int, float, str, bool, None] = None,
-    ) -> Union[int, float, str, bool]:
-        """Get an option's value.
-
-        If multiple values are specified for this option in the section, the last one
-        specified is returned.
-
-        :param default:
-            If not ``None``, the given default value will be returned in case the option
-            did not exist.
-
-        :return:
-            A properly typed value, either int, float or string
-
-        :raise TypeError:
-            In case the value could not be understood.
-            Otherwise the exceptions known to the ConfigParser will be raised.
-        """
-        try:
-            valuestr = self.get(section, option)
-        except Exception:
-            if default is not None:
-                return default
-            raise
-
-        return self._string_to_value(valuestr)
-
-    def get_values(
-        self,
-        section: str,
-        option: str,
-        default: Union[int, float, str, bool, None] = None,
-    ) -> List[Union[int, float, str, bool]]:
-        """Get an option's values.
-
-        If multiple values are specified for this option in the section, all are
-        returned.
-
-        :param default:
-            If not ``None``, a list containing the given default value will be returned
-            in case the option did not exist.
-
-        :return:
-            A list of properly typed values, either int, float or string
-
-        :raise TypeError:
-            In case the value could not be understood.
-            Otherwise the exceptions known to the ConfigParser will be raised.
-        """
-        try:
-            self.sections()
-            lst = self._sections[section].getall(option)
-        except Exception:
-            if default is not None:
-                return [default]
-            raise
-
-        return [self._string_to_value(valuestr) for valuestr in lst]
-
-    def _string_to_value(self, valuestr: str) -> Union[int, float, str, bool]:
-        types = (int, float)
-        for numtype in types:
-            try:
-                val = numtype(valuestr)
-                # truncated value ?
-                if val != float(valuestr):
-                    continue
-                return val
-            except (ValueError, TypeError):
-                continue
-        # END for each numeric type
-
-        # Try boolean values as git uses them.
-        vl = valuestr.lower()
-        if vl == "false":
-            return False
-        if vl == "true":
-            return True
-
-        if not isinstance(valuestr, str):
-            raise TypeError(
-                "Invalid value type: only int, long, float and str are allowed",
-                valuestr,
-            )
-
-        return valuestr
-
-    def _value_to_string(self, value: Union[str, bytes, int, float, bool]) -> str:
-        if isinstance(value, (int, float, bool)):
-            return str(value)
-        return force_text(value)
-
-    @needs_values
-    @set_dirty_and_flush_changes
-    def set_value(self, section: str, option: str, value: Union[str, bytes, int, float, bool]) -> "GitConfigParser":
-        """Set the given option in section to the given value.
-
-        This will create the section if required, and will not throw as opposed to the
-        default ConfigParser ``set`` method.
-
-        :param section:
-            Name of the section in which the option resides or should reside.
-
-        :param option:
-            Name of the options whose value to set.
-
-        :param value:
-            Value to set the option to. It must be a string or convertible to a string.
-
-        :return:
-            This instance
-        """
-        if not self.has_section(section):
-            self.add_section(section)
-        self.set(section, option, self._value_to_string(value))
-        return self
-
-    @needs_values
-    @set_dirty_and_flush_changes
-    def add_value(self, section: str, option: str, value: Union[str, bytes, int, float, bool]) -> "GitConfigParser":
-        """Add a value for the given option in section.
-
-        This will create the section if required, and will not throw as opposed to the
-        default ConfigParser ``set`` method. The value becomes the new value of the
-        option as returned by :meth:`get_value`, and appends to the list of values
-        returned by :meth:`get_values`.
-
-        :param section:
-            Name of the section in which the option resides or should reside.
-
-        :param option:
-            Name of the option.
-
-        :param value:
-            Value to add to option. It must be a string or convertible to a string.
-
-        :return:
-            This instance
-        """
-        if not self.has_section(section):
-            self.add_section(section)
-        self._sections[section].add(option, self._value_to_string(value))
-        return self
-
-    def rename_section(self, section: str, new_name: str) -> "GitConfigParser":
-        """Rename the given section to `new_name`.
-
-        :raise ValueError:
-            If:
-
-            * `section` doesn't exist.
-            * A section with `new_name` does already exist.
-
-        :return:
-            This instance
-        """
-        if not self.has_section(section):
-            raise ValueError("Source section '%s' doesn't exist" % section)
-        if self.has_section(new_name):
-            raise ValueError("Destination section '%s' already exists" % new_name)
-
-        super().add_section(new_name)
-        new_section = self._sections[new_name]
-        for k, vs in self.items_all(section):
-            new_section.setall(k, vs)
-        # END for each value to copy
-
-        # This call writes back the changes, which is why we don't have the respective
-        # decorator.
-        self.remove_section(section)
-        return self

ILYA/Lib/site-packages/git/db.py

@@ -1,71 +0,0 @@
-# This module is part of GitPython and is released under the
-# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
-
-"""Module with our own gitdb implementation - it uses the git command."""
-
-__all__ = ["GitCmdObjectDB", "GitDB"]
-
-from gitdb.base import OInfo, OStream
-from gitdb.db import GitDB, LooseObjectDB
-from gitdb.exc import BadObject
-
-from git.util import bin_to_hex, hex_to_bin
-from git.exc import GitCommandError
-
-# typing-------------------------------------------------
-
-from typing import TYPE_CHECKING
-
-from git.types import PathLike
-
-if TYPE_CHECKING:
-    from git.cmd import Git
-
-# --------------------------------------------------------
-
-
-class GitCmdObjectDB(LooseObjectDB):
-    """A database representing the default git object store, which includes loose
-    objects, pack files and an alternates file.
-
-    It will create objects only in the loose object database.
-    """
-
-    def __init__(self, root_path: PathLike, git: "Git") -> None:
-        """Initialize this instance with the root and a git command."""
-        super().__init__(root_path)
-        self._git = git
-
-    def info(self, binsha: bytes) -> OInfo:
-        """Get a git object header (using git itself)."""
-        hexsha, typename, size = self._git.get_object_header(bin_to_hex(binsha))
-        return OInfo(hex_to_bin(hexsha), typename, size)
-
-    def stream(self, binsha: bytes) -> OStream:
-        """Get git object data as a stream supporting ``read()`` (using git itself)."""
-        hexsha, typename, size, stream = self._git.stream_object_data(bin_to_hex(binsha))
-        return OStream(hex_to_bin(hexsha), typename, size, stream)
-
-    # { Interface
-
-    def partial_to_complete_sha_hex(self, partial_hexsha: str) -> bytes:
-        """
-        :return:
-            Full binary 20 byte sha from the given partial hexsha
-
-        :raise gitdb.exc.AmbiguousObjectName:
-
-        :raise gitdb.exc.BadObject:
-
-        :note:
-            Currently we only raise :exc:`~gitdb.exc.BadObject` as git does not
-            communicate ambiguous objects separately.
-        """
-        try:
-            hexsha, _typename, _size = self._git.get_object_header(partial_hexsha)
-            return hex_to_bin(hexsha)
-        except (GitCommandError, ValueError) as e:
-            raise BadObject(partial_hexsha) from e
-        # END handle exceptions
-
-    # } END interface

ILYA/Lib/site-packages/git/diff.py

@@ -1,775 +0,0 @@
-# Copyright (C) 2008, 2009 Michael Trier ([email protected]) and contributors
-#
-# This module is part of GitPython and is released under the
-# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
-
-__all__ = ["DiffConstants", "NULL_TREE", "INDEX", "Diffable", "DiffIndex", "Diff"]
-
-import enum
-import re
-import warnings
-
-from git.cmd import handle_process_output
-from git.compat import defenc
-from git.objects.blob import Blob
-from git.objects.util import mode_str_to_int
-from git.util import finalize_process, hex_to_bin
-
-# typing ------------------------------------------------------------------
-
-from typing import (
-    Any,
-    Iterator,
-    List,
-    Match,
-    Optional,
-    Tuple,
-    TYPE_CHECKING,
-    TypeVar,
-    Union,
-    cast,
-)
-from git.types import Literal, PathLike
-
-if TYPE_CHECKING:
-    from subprocess import Popen
-
-    from git.cmd import Git
-    from git.objects.base import IndexObject
-    from git.objects.commit import Commit
-    from git.objects.tree import Tree
-    from git.repo.base import Repo
-
-Lit_change_type = Literal["A", "D", "C", "M", "R", "T", "U"]
-
-# ------------------------------------------------------------------------
-
-
-@enum.unique
-class DiffConstants(enum.Enum):
-    """Special objects for :meth:`Diffable.diff`.
-
-    See the :meth:`Diffable.diff` method's ``other`` parameter, which accepts various
-    values including these.
-
-    :note:
-        These constants are also available as attributes of the :mod:`git.diff` module,
-        the :class:`Diffable` class and its subclasses and instances, and the top-level
-        :mod:`git` module.
-    """
-
-    NULL_TREE = enum.auto()
-    """Stand-in indicating you want to compare against the empty tree in diffs.
-
-    Also accessible as :const:`git.NULL_TREE`, :const:`git.diff.NULL_TREE`, and
-    :const:`Diffable.NULL_TREE`.
-    """
-
-    INDEX = enum.auto()
-    """Stand-in indicating you want to diff against the index.
-
-    Also accessible as :const:`git.INDEX`, :const:`git.diff.INDEX`, and
-    :const:`Diffable.INDEX`, as well as :const:`Diffable.Index`. The latter has been
-    kept for backward compatibility and made an alias of this, so it may still be used.
-    """
-
-
-NULL_TREE: Literal[DiffConstants.NULL_TREE] = DiffConstants.NULL_TREE
-"""Stand-in indicating you want to compare against the empty tree in diffs.
-
-See :meth:`Diffable.diff`, which accepts this as a value of its ``other`` parameter.
-
-This is an alias of :const:`DiffConstants.NULL_TREE`, which may also be accessed as
-:const:`git.NULL_TREE` and :const:`Diffable.NULL_TREE`.
-"""
-
-INDEX: Literal[DiffConstants.INDEX] = DiffConstants.INDEX
-"""Stand-in indicating you want to diff against the index.
-
-See :meth:`Diffable.diff`, which accepts this as a value of its ``other`` parameter.
-
-This is an alias of :const:`DiffConstants.INDEX`, which may also be accessed as
-:const:`git.INDEX` and :const:`Diffable.INDEX`, as well as :const:`Diffable.Index`.
-"""
-
-_octal_byte_re = re.compile(rb"\\([0-9]{3})")
-
-
-def _octal_repl(matchobj: Match) -> bytes:
-    value = matchobj.group(1)
-    value = int(value, 8)
-    value = bytes(bytearray((value,)))
-    return value
-
-
-def decode_path(path: bytes, has_ab_prefix: bool = True) -> Optional[bytes]:
-    if path == b"/dev/null":
-        return None
-
-    if path.startswith(b'"') and path.endswith(b'"'):
-        path = path[1:-1].replace(b"\\n", b"\n").replace(b"\\t", b"\t").replace(b'\\"', b'"').replace(b"\\\\", b"\\")
-
-    path = _octal_byte_re.sub(_octal_repl, path)
-
-    if has_ab_prefix:
-        assert path.startswith(b"a/") or path.startswith(b"b/")
-        path = path[2:]
-
-    return path
-
-
-class Diffable:
-    """Common interface for all objects that can be diffed against another object of
-    compatible type.
-
-    :note:
-        Subclasses require a :attr:`repo` member, as it is the case for
-        :class:`~git.objects.base.Object` instances. For practical reasons we do not
-        derive from :class:`~git.objects.base.Object`.
-    """
-
-    __slots__ = ()
-
-    repo: "Repo"
-    """Repository to operate on. Must be provided by subclass or sibling class."""
-
-    NULL_TREE = NULL_TREE
-    """Stand-in indicating you want to compare against the empty tree in diffs.
-
-    See the :meth:`diff` method, which accepts this as a value of its ``other``
-    parameter.
-
-    This is the same as :const:`DiffConstants.NULL_TREE`, and may also be accessed as
-    :const:`git.NULL_TREE` and :const:`git.diff.NULL_TREE`.
-    """
-
-    INDEX = INDEX
-    """Stand-in indicating you want to diff against the index.
-
-    See the :meth:`diff` method, which accepts this as a value of its ``other``
-    parameter.
-
-    This is the same as :const:`DiffConstants.INDEX`, and may also be accessed as
-    :const:`git.INDEX` and :const:`git.diff.INDEX`, as well as :class:`Diffable.INDEX`,
-    which is kept for backward compatibility (it is now defined an alias of this).
-    """
-
-    Index = INDEX
-    """Stand-in indicating you want to diff against the index
-    (same as :const:`~Diffable.INDEX`).
-
-    This is an alias of :const:`~Diffable.INDEX`, for backward compatibility. See
-    :const:`~Diffable.INDEX` and :meth:`diff` for details.
-
-    :note:
-        Although always meant for use as an opaque constant, this was formerly defined
-        as a class. Its usage is unchanged, but static type annotations that attempt
-        to permit only this object must be changed to avoid new mypy errors. This was
-        previously not possible to do, though ``Type[Diffable.Index]`` approximated it.
-        It is now possible to do precisely, using ``Literal[DiffConstants.INDEX]``.
-    """
-
-    def _process_diff_args(
-        self,
-        args: List[Union[PathLike, "Diffable"]],
-    ) -> List[Union[PathLike, "Diffable"]]:
-        """
-        :return:
-            Possibly altered version of the given args list.
-            This method is called right before git command execution.
-            Subclasses can use it to alter the behaviour of the superclass.
-        """
-        return args
-
-    def diff(
-        self,
-        other: Union[DiffConstants, "Tree", "Commit", str, None] = INDEX,
-        paths: Union[PathLike, List[PathLike], Tuple[PathLike, ...], None] = None,
-        create_patch: bool = False,
-        **kwargs: Any,
-    ) -> "DiffIndex":
-        """Create diffs between two items being trees, trees and index or an index and
-        the working tree. Detects renames automatically.
-
-        :param other:
-            This the item to compare us with.
-
-            * If ``None``, we will be compared to the working tree.
-
-            * If a :class:`~git.types.Tree_ish` or string, it will be compared against
-              the respective tree.
-
-            * If :const:`INDEX`, it will be compared against the index.
-
-            * If :const:`NULL_TREE`, it will compare against the empty tree.
-
-            This parameter defaults to :const:`INDEX` (rather than ``None``) so that the
-            method will not by default fail on bare repositories.
-
-        :param paths:
-            This a list of paths or a single path to limit the diff to. It will only
-            include at least one of the given path or paths.
-
-        :param create_patch:
-            If ``True``, the returned :class:`Diff` contains a detailed patch that if
-            applied makes the self to other. Patches are somewhat costly as blobs have
-            to be read and diffed.
-
-        :param kwargs:
-            Additional arguments passed to :manpage:`git-diff(1)`, such as ``R=True`` to
-            swap both sides of the diff.
-
-        :return:
-            A :class:`DiffIndex` representing the computed diff.
-
-        :note:
-            On a bare repository, `other` needs to be provided as :const:`INDEX`, or as
-            an instance of :class:`~git.objects.tree.Tree` or
-            :class:`~git.objects.commit.Commit`, or a git command error will occur.
-        """
-        args: List[Union[PathLike, Diffable]] = []
-        args.append("--abbrev=40")  # We need full shas.
-        args.append("--full-index")  # Get full index paths, not only filenames.
-
-        # Remove default '-M' arg (check for renames) if user is overriding it.
-        if not any(x in kwargs for x in ("find_renames", "no_renames", "M")):
-            args.append("-M")
-
-        if create_patch:
-            args.append("-p")
-            args.append("--no-ext-diff")
-        else:
-            args.append("--raw")
-            args.append("-z")
-
-        # Ensure we never see colored output.
-        # Fixes: https://github.com/gitpython-developers/GitPython/issues/172
-        args.append("--no-color")
-
-        if paths is not None and not isinstance(paths, (tuple, list)):
-            paths = [paths]
-
-        diff_cmd = self.repo.git.diff
-        if other is INDEX:
-            args.insert(0, "--cached")
-        elif other is NULL_TREE:
-            args.insert(0, "-r")  # Recursive diff-tree.
-            args.insert(0, "--root")
-            diff_cmd = self.repo.git.diff_tree
-        elif other is not None:
-            args.insert(0, "-r")  # Recursive diff-tree.
-            args.insert(0, other)
-            diff_cmd = self.repo.git.diff_tree
-
-        args.insert(0, self)
-
-        # paths is a list or tuple here, or None.
-        if paths:
-            args.append("--")
-            args.extend(paths)
-        # END paths handling
-
-        kwargs["as_process"] = True
-        proc = diff_cmd(*self._process_diff_args(args), **kwargs)
-
-        diff_method = Diff._index_from_patch_format if create_patch else Diff._index_from_raw_format
-        index = diff_method(self.repo, proc)
-
-        proc.wait()
-        return index
-
-
-T_Diff = TypeVar("T_Diff", bound="Diff")
-
-
-class DiffIndex(List[T_Diff]):
-    R"""An index for diffs, allowing a list of :class:`Diff`\s to be queried by the diff
-    properties.
-
-    The class improves the diff handling convenience.
-    """
-
-    change_type = ("A", "C", "D", "R", "M", "T")
-    """Change type invariant identifying possible ways a blob can have changed:
-
-    * ``A`` = Added
-    * ``D`` = Deleted
-    * ``R`` = Renamed
-    * ``M`` = Modified
-    * ``T`` = Changed in the type
-    """
-
-    def iter_change_type(self, change_type: Lit_change_type) -> Iterator[T_Diff]:
-        """
-        :return:
-            Iterator yielding :class:`Diff` instances that match the given `change_type`
-
-        :param change_type:
-            Member of :attr:`DiffIndex.change_type`, namely:
-
-            * 'A' for added paths
-            * 'D' for deleted paths
-            * 'R' for renamed paths
-            * 'M' for paths with modified data
-            * 'T' for changed in the type paths
-        """
-        if change_type not in self.change_type:
-            raise ValueError("Invalid change type: %s" % change_type)
-
-        for diffidx in self:
-            if diffidx.change_type == change_type:
-                yield diffidx
-            elif change_type == "A" and diffidx.new_file:
-                yield diffidx
-            elif change_type == "D" and diffidx.deleted_file:
-                yield diffidx
-            elif change_type == "C" and diffidx.copied_file:
-                yield diffidx
-            elif change_type == "R" and diffidx.renamed:
-                yield diffidx
-            elif change_type == "M" and diffidx.a_blob and diffidx.b_blob and diffidx.a_blob != diffidx.b_blob:
-                yield diffidx
-        # END for each diff
-
-
-class Diff:
-    """A Diff contains diff information between two Trees.
-
-    It contains two sides a and b of the diff. Members are prefixed with "a" and "b"
-    respectively to indicate that.
-
-    Diffs keep information about the changed blob objects, the file mode, renames,
-    deletions and new files.
-
-    There are a few cases where ``None`` has to be expected as member variable value:
-
-    New File::
-
-        a_mode is None
-        a_blob is None
-        a_path is None
-
-    Deleted File::
-
-        b_mode is None
-        b_blob is None
-        b_path is None
-
-    Working Tree Blobs:
-
-        When comparing to working trees, the working tree blob will have a null hexsha
-        as a corresponding object does not yet exist. The mode will be null as well. The
-        path will be available, though.
-
-        If it is listed in a diff, the working tree version of the file must differ from
-        the version in the index or tree, and hence has been modified.
-    """
-
-    # Precompiled regex.
-    re_header = re.compile(
-        rb"""
-                                ^diff[ ]--git
-                                    [ ](?P<a_path_fallback>"?[ab]/.+?"?)[ ](?P<b_path_fallback>"?[ab]/.+?"?)\n
-                                (?:^old[ ]mode[ ](?P<old_mode>\d+)\n
-                                   ^new[ ]mode[ ](?P<new_mode>\d+)(?:\n|$))?
-                                (?:^similarity[ ]index[ ]\d+%\n
-                                   ^rename[ ]from[ ](?P<rename_from>.*)\n
-                                   ^rename[ ]to[ ](?P<rename_to>.*)(?:\n|$))?
-                                (?:^new[ ]file[ ]mode[ ](?P<new_file_mode>.+)(?:\n|$))?
-                                (?:^deleted[ ]file[ ]mode[ ](?P<deleted_file_mode>.+)(?:\n|$))?
-                                (?:^similarity[ ]index[ ]\d+%\n
-                                   ^copy[ ]from[ ].*\n
-                                   ^copy[ ]to[ ](?P<copied_file_name>.*)(?:\n|$))?
-                                (?:^index[ ](?P<a_blob_id>[0-9A-Fa-f]+)
-                                    \.\.(?P<b_blob_id>[0-9A-Fa-f]+)[ ]?(?P<b_mode>.+)?(?:\n|$))?
-                                (?:^---[ ](?P<a_path>[^\t\n\r\f\v]*)[\t\r\f\v]*(?:\n|$))?
-                                (?:^\+\+\+[ ](?P<b_path>[^\t\n\r\f\v]*)[\t\r\f\v]*(?:\n|$))?
-                            """,
-        re.VERBOSE | re.MULTILINE,
-    )
-
-    # These can be used for comparisons.
-    NULL_HEX_SHA = "0" * 40
-    NULL_BIN_SHA = b"\0" * 20
-
-    __slots__ = (
-        "a_blob",
-        "b_blob",
-        "a_mode",
-        "b_mode",
-        "a_rawpath",
-        "b_rawpath",
-        "new_file",
-        "deleted_file",
-        "copied_file",
-        "raw_rename_from",
-        "raw_rename_to",
-        "diff",
-        "change_type",
-        "score",
-    )
-
-    def __init__(
-        self,
-        repo: "Repo",
-        a_rawpath: Optional[bytes],
-        b_rawpath: Optional[bytes],
-        a_blob_id: Union[str, bytes, None],
-        b_blob_id: Union[str, bytes, None],
-        a_mode: Union[bytes, str, None],
-        b_mode: Union[bytes, str, None],
-        new_file: bool,
-        deleted_file: bool,
-        copied_file: bool,
-        raw_rename_from: Optional[bytes],
-        raw_rename_to: Optional[bytes],
-        diff: Union[str, bytes, None],
-        change_type: Optional[Lit_change_type],
-        score: Optional[int],
-    ) -> None:
-        assert a_rawpath is None or isinstance(a_rawpath, bytes)
-        assert b_rawpath is None or isinstance(b_rawpath, bytes)
-        self.a_rawpath = a_rawpath
-        self.b_rawpath = b_rawpath
-
-        self.a_mode = mode_str_to_int(a_mode) if a_mode else None
-        self.b_mode = mode_str_to_int(b_mode) if b_mode else None
-
-        # Determine whether this diff references a submodule. If it does then
-        # we need to overwrite "repo" to the corresponding submodule's repo instead.
-        if repo and a_rawpath:
-            for submodule in repo.submodules:
-                if submodule.path == a_rawpath.decode(defenc, "replace"):
-                    if submodule.module_exists():
-                        repo = submodule.module()
-                    break
-
-        self.a_blob: Union["IndexObject", None]
-        if a_blob_id is None or a_blob_id == self.NULL_HEX_SHA:
-            self.a_blob = None
-        else:
-            self.a_blob = Blob(repo, hex_to_bin(a_blob_id), mode=self.a_mode, path=self.a_path)
-
-        self.b_blob: Union["IndexObject", None]
-        if b_blob_id is None or b_blob_id == self.NULL_HEX_SHA:
-            self.b_blob = None
-        else:
-            self.b_blob = Blob(repo, hex_to_bin(b_blob_id), mode=self.b_mode, path=self.b_path)
-
-        self.new_file: bool = new_file
-        self.deleted_file: bool = deleted_file
-        self.copied_file: bool = copied_file
-
-        # Be clear and use None instead of empty strings.
-        assert raw_rename_from is None or isinstance(raw_rename_from, bytes)
-        assert raw_rename_to is None or isinstance(raw_rename_to, bytes)
-        self.raw_rename_from = raw_rename_from or None
-        self.raw_rename_to = raw_rename_to or None
-
-        self.diff = diff
-        self.change_type: Union[Lit_change_type, None] = change_type
-        self.score = score
-
-    def __eq__(self, other: object) -> bool:
-        for name in self.__slots__:
-            if getattr(self, name) != getattr(other, name):
-                return False
-        # END for each name
-        return True
-
-    def __ne__(self, other: object) -> bool:
-        return not (self == other)
-
-    def __hash__(self) -> int:
-        return hash(tuple(getattr(self, n) for n in self.__slots__))
-
-    def __str__(self) -> str:
-        h = "%s"
-        if self.a_blob:
-            h %= self.a_blob.path
-        elif self.b_blob:
-            h %= self.b_blob.path
-
-        msg = ""
-        line = None
-        line_length = 0
-        for b, n in zip((self.a_blob, self.b_blob), ("lhs", "rhs")):
-            if b:
-                line = "\n%s: %o | %s" % (n, b.mode, b.hexsha)
-            else:
-                line = "\n%s: None" % n
-            # END if blob is not None
-            line_length = max(len(line), line_length)
-            msg += line
-        # END for each blob
-
-        # Add headline.
-        h += "\n" + "=" * line_length
-
-        if self.deleted_file:
-            msg += "\nfile deleted in rhs"
-        if self.new_file:
-            msg += "\nfile added in rhs"
-        if self.copied_file:
-            msg += "\nfile %r copied from %r" % (self.b_path, self.a_path)
-        if self.rename_from:
-            msg += "\nfile renamed from %r" % self.rename_from
-        if self.rename_to:
-            msg += "\nfile renamed to %r" % self.rename_to
-        if self.diff:
-            msg += "\n---"
-            try:
-                msg += self.diff.decode(defenc) if isinstance(self.diff, bytes) else self.diff
-            except UnicodeDecodeError:
-                msg += "OMITTED BINARY DATA"
-            # END handle encoding
-            msg += "\n---"
-        # END diff info
-
-        return h + msg
-
-    @property
-    def a_path(self) -> Optional[str]:
-        return self.a_rawpath.decode(defenc, "replace") if self.a_rawpath else None
-
-    @property
-    def b_path(self) -> Optional[str]:
-        return self.b_rawpath.decode(defenc, "replace") if self.b_rawpath else None
-
-    @property
-    def rename_from(self) -> Optional[str]:
-        return self.raw_rename_from.decode(defenc, "replace") if self.raw_rename_from else None
-
-    @property
-    def rename_to(self) -> Optional[str]:
-        return self.raw_rename_to.decode(defenc, "replace") if self.raw_rename_to else None
-
-    @property
-    def renamed(self) -> bool:
-        """Deprecated, use :attr:`renamed_file` instead.
-
-        :return:
-            ``True`` if the blob of our diff has been renamed
-
-        :note:
-            This property is deprecated.
-            Please use the :attr:`renamed_file` property instead.
-        """
-        warnings.warn(
-            "Diff.renamed is deprecated, use Diff.renamed_file instead",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        return self.renamed_file
-
-    @property
-    def renamed_file(self) -> bool:
-        """:return: ``True`` if the blob of our diff has been renamed"""
-        return self.rename_from != self.rename_to
-
-    @classmethod
-    def _pick_best_path(cls, path_match: bytes, rename_match: bytes, path_fallback_match: bytes) -> Optional[bytes]:
-        if path_match:
-            return decode_path(path_match)
-
-        if rename_match:
-            return decode_path(rename_match, has_ab_prefix=False)
-
-        if path_fallback_match:
-            return decode_path(path_fallback_match)
-
-        return None
-
-    @classmethod
-    def _index_from_patch_format(cls, repo: "Repo", proc: Union["Popen", "Git.AutoInterrupt"]) -> DiffIndex:
-        """Create a new :class:`DiffIndex` from the given process output which must be
-        in patch format.
-
-        :param repo:
-            The repository we are operating on.
-
-        :param proc:
-            :manpage:`git-diff(1)` process to read from
-            (supports :class:`Git.AutoInterrupt <git.cmd.Git.AutoInterrupt>` wrapper).
-
-        :return:
-            :class:`DiffIndex`
-        """
-
-        # FIXME: Here SLURPING raw, need to re-phrase header-regexes linewise.
-        text_list: List[bytes] = []
-        handle_process_output(proc, text_list.append, None, finalize_process, decode_streams=False)
-
-        # For now, we have to bake the stream.
-        text = b"".join(text_list)
-        index: "DiffIndex" = DiffIndex()
-        previous_header: Union[Match[bytes], None] = None
-        header: Union[Match[bytes], None] = None
-        a_path, b_path = None, None  # For mypy.
-        a_mode, b_mode = None, None  # For mypy.
-        for _header in cls.re_header.finditer(text):
-            (
-                a_path_fallback,
-                b_path_fallback,
-                old_mode,
-                new_mode,
-                rename_from,
-                rename_to,
-                new_file_mode,
-                deleted_file_mode,
-                copied_file_name,
-                a_blob_id,
-                b_blob_id,
-                b_mode,
-                a_path,
-                b_path,
-            ) = _header.groups()
-
-            new_file, deleted_file, copied_file = (
-                bool(new_file_mode),
-                bool(deleted_file_mode),
-                bool(copied_file_name),
-            )
-
-            a_path = cls._pick_best_path(a_path, rename_from, a_path_fallback)
-            b_path = cls._pick_best_path(b_path, rename_to, b_path_fallback)
-
-            # Our only means to find the actual text is to see what has not been matched
-            # by our regex, and then retro-actively assign it to our index.
-            if previous_header is not None:
-                index[-1].diff = text[previous_header.end() : _header.start()]
-            # END assign actual diff
-
-            # Make sure the mode is set if the path is set. Otherwise the resulting blob
-            # is invalid. We just use the one mode we should have parsed.
-            a_mode = old_mode or deleted_file_mode or (a_path and (b_mode or new_mode or new_file_mode))
-            b_mode = b_mode or new_mode or new_file_mode or (b_path and a_mode)
-            index.append(
-                Diff(
-                    repo,
-                    a_path,
-                    b_path,
-                    a_blob_id and a_blob_id.decode(defenc),
-                    b_blob_id and b_blob_id.decode(defenc),
-                    a_mode and a_mode.decode(defenc),
-                    b_mode and b_mode.decode(defenc),
-                    new_file,
-                    deleted_file,
-                    copied_file,
-                    rename_from,
-                    rename_to,
-                    None,
-                    None,
-                    None,
-                )
-            )
-
-            previous_header = _header
-            header = _header
-        # END for each header we parse
-        if index and header:
-            index[-1].diff = text[header.end() :]
-        # END assign last diff
-
-        return index
-
-    @staticmethod
-    def _handle_diff_line(lines_bytes: bytes, repo: "Repo", index: DiffIndex) -> None:
-        lines = lines_bytes.decode(defenc)
-
-        # Discard everything before the first colon, and the colon itself.
-        _, _, lines = lines.partition(":")
-
-        for line in lines.split("\x00:"):
-            if not line:
-                # The line data is empty, skip.
-                continue
-            meta, _, path = line.partition("\x00")
-            path = path.rstrip("\x00")
-            a_blob_id: Optional[str]
-            b_blob_id: Optional[str]
-            old_mode, new_mode, a_blob_id, b_blob_id, _change_type = meta.split(None, 4)
-            # Change type can be R100
-            # R: status letter
-            # 100: score (in case of copy and rename)
-            change_type: Lit_change_type = cast(Lit_change_type, _change_type[0])
-            score_str = "".join(_change_type[1:])
-            score = int(score_str) if score_str.isdigit() else None
-            path = path.strip()
-            a_path = path.encode(defenc)
-            b_path = path.encode(defenc)
-            deleted_file = False
-            new_file = False
-            copied_file = False
-            rename_from = None
-            rename_to = None
-
-            # NOTE: We cannot conclude from the existence of a blob to change type,
-            # as diffs with the working do not have blobs yet.
-            if change_type == "D":
-                b_blob_id = None  # Optional[str]
-                deleted_file = True
-            elif change_type == "A":
-                a_blob_id = None
-                new_file = True
-            elif change_type == "C":
-                copied_file = True
-                a_path_str, b_path_str = path.split("\x00", 1)
-                a_path = a_path_str.encode(defenc)
-                b_path = b_path_str.encode(defenc)
-            elif change_type == "R":
-                a_path_str, b_path_str = path.split("\x00", 1)
-                a_path = a_path_str.encode(defenc)
-                b_path = b_path_str.encode(defenc)
-                rename_from, rename_to = a_path, b_path
-            elif change_type == "T":
-                # Nothing to do.
-                pass
-            # END add/remove handling
-
-            diff = Diff(
-                repo,
-                a_path,
-                b_path,
-                a_blob_id,
-                b_blob_id,
-                old_mode,
-                new_mode,
-                new_file,
-                deleted_file,
-                copied_file,
-                rename_from,
-                rename_to,
-                "",
-                change_type,
-                score,
-            )
-            index.append(diff)
-
-    @classmethod
-    def _index_from_raw_format(cls, repo: "Repo", proc: "Popen") -> "DiffIndex":
-        """Create a new :class:`DiffIndex` from the given process output which must be
-        in raw format.
-
-        :param repo:
-            The repository we are operating on.
-
-        :param proc:
-            Process to read output from.
-
-        :return:
-            :class:`DiffIndex`
-        """
-        # handles
-        # :100644 100644 687099101... 37c5e30c8... M    .gitignore
-
-        index: "DiffIndex" = DiffIndex()
-        handle_process_output(
-            proc,
-            lambda byt: cls._handle_diff_line(byt, repo, index),
-            None,
-            finalize_process,
-            decode_streams=False,
-        )
-
-        return index

ILYA/Lib/site-packages/git/exc.py

@@ -1,228 +0,0 @@
-# Copyright (C) 2008, 2009 Michael Trier ([email protected]) and contributors
-#
-# This module is part of GitPython and is released under the
-# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
-
-"""Exceptions thrown throughout the git package."""
-
-__all__ = [
-    # Defined in gitdb.exc:
-    "AmbiguousObjectName",
-    "BadName",
-    "BadObject",
-    "BadObjectType",
-    "InvalidDBRoot",
-    "ODBError",
-    "ParseError",
-    "UnsupportedOperation",
-    # Introduced in this module:
-    "GitError",
-    "InvalidGitRepositoryError",
-    "WorkTreeRepositoryUnsupported",
-    "NoSuchPathError",
-    "UnsafeProtocolError",
-    "UnsafeOptionError",
-    "CommandError",
-    "GitCommandNotFound",
-    "GitCommandError",
-    "CheckoutError",
-    "CacheError",
-    "UnmergedEntriesError",
-    "HookExecutionError",
-    "RepositoryDirtyError",
-]
-
-from gitdb.exc import (
-    AmbiguousObjectName,
-    BadName,
-    BadObject,
-    BadObjectType,
-    InvalidDBRoot,
-    ODBError,
-    ParseError,
-    UnsupportedOperation,
-)
-
-from git.compat import safe_decode
-from git.util import remove_password_if_present
-
-# typing ----------------------------------------------------
-
-from typing import List, Sequence, Tuple, TYPE_CHECKING, Union
-
-from git.types import PathLike
-
-if TYPE_CHECKING:
-    from git.repo.base import Repo
-
-# ------------------------------------------------------------------
-
-
-class GitError(Exception):
-    """Base class for all package exceptions."""
-
-
-class InvalidGitRepositoryError(GitError):
-    """Thrown if the given repository appears to have an invalid format."""
-
-
-class WorkTreeRepositoryUnsupported(InvalidGitRepositoryError):
-    """Thrown to indicate we can't handle work tree repositories."""
-
-
-class NoSuchPathError(GitError, OSError):
-    """Thrown if a path could not be access by the system."""
-
-
-class UnsafeProtocolError(GitError):
-    """Thrown if unsafe protocols are passed without being explicitly allowed."""
-
-
-class UnsafeOptionError(GitError):
-    """Thrown if unsafe options are passed without being explicitly allowed."""
-
-
-class CommandError(GitError):
-    """Base class for exceptions thrown at every stage of :class:`~subprocess.Popen`
-    execution.
-
-    :param command:
-        A non-empty list of argv comprising the command-line.
-    """
-
-    _msg = "Cmd('%s') failed%s"
-    """Format string with 2 ``%s`` for ``<cmdline>`` and the rest.
-
-    For example: ``"'%s' failed%s"``
-
-    Subclasses may override this attribute, provided it is still in this form.
-    """
-
-    def __init__(
-        self,
-        command: Union[List[str], Tuple[str, ...], str],
-        status: Union[str, int, None, Exception] = None,
-        stderr: Union[bytes, str, None] = None,
-        stdout: Union[bytes, str, None] = None,
-    ) -> None:
-        if not isinstance(command, (tuple, list)):
-            command = command.split()
-        self.command = remove_password_if_present(command)
-        self.status = status
-        if status:
-            if isinstance(status, Exception):
-                status = "%s('%s')" % (type(status).__name__, safe_decode(str(status)))
-            else:
-                try:
-                    status = "exit code(%s)" % int(status)
-                except (ValueError, TypeError):
-                    s = safe_decode(str(status))
-                    status = "'%s'" % s if isinstance(status, str) else s
-
-        self._cmd = safe_decode(self.command[0])
-        self._cmdline = " ".join(safe_decode(i) for i in self.command)
-        self._cause = status and " due to: %s" % status or "!"
-        stdout_decode = safe_decode(stdout)
-        stderr_decode = safe_decode(stderr)
-        self.stdout = stdout_decode and "\n  stdout: '%s'" % stdout_decode or ""
-        self.stderr = stderr_decode and "\n  stderr: '%s'" % stderr_decode or ""
-
-    def __str__(self) -> str:
-        return (self._msg + "\n  cmdline: %s%s%s") % (
-            self._cmd,
-            self._cause,
-            self._cmdline,
-            self.stdout,
-            self.stderr,
-        )
-
-
-class GitCommandNotFound(CommandError):
-    """Thrown if we cannot find the ``git`` executable in the :envvar:`PATH` or at the
-    path given by the :envvar:`GIT_PYTHON_GIT_EXECUTABLE` environment variable."""
-
-    def __init__(self, command: Union[List[str], Tuple[str], str], cause: Union[str, Exception]) -> None:
-        super().__init__(command, cause)
-        self._msg = "Cmd('%s') not found%s"
-
-
-class GitCommandError(CommandError):
-    """Thrown if execution of the git command fails with non-zero status code."""
-
-    def __init__(
-        self,
-        command: Union[List[str], Tuple[str, ...], str],
-        status: Union[str, int, None, Exception] = None,
-        stderr: Union[bytes, str, None] = None,
-        stdout: Union[bytes, str, None] = None,
-    ) -> None:
-        super().__init__(command, status, stderr, stdout)
-
-
-class CheckoutError(GitError):
-    """Thrown if a file could not be checked out from the index as it contained
-    changes.
-
-    The :attr:`failed_files` attribute contains a list of relative paths that failed to
-    be checked out as they contained changes that did not exist in the index.
-
-    The :attr:`failed_reasons` attribute contains a string informing about the actual
-    cause of the issue.
-
-    The :attr:`valid_files` attribute contains a list of relative paths to files that
-    were checked out successfully and hence match the version stored in the index.
-    """
-
-    def __init__(
-        self,
-        message: str,
-        failed_files: Sequence[PathLike],
-        valid_files: Sequence[PathLike],
-        failed_reasons: List[str],
-    ) -> None:
-        Exception.__init__(self, message)
-        self.failed_files = failed_files
-        self.failed_reasons = failed_reasons
-        self.valid_files = valid_files
-
-    def __str__(self) -> str:
-        return Exception.__str__(self) + ":%s" % self.failed_files
-
-
-class CacheError(GitError):
-    """Base for all errors related to the git index, which is called "cache"
-    internally."""
-
-
-class UnmergedEntriesError(CacheError):
-    """Thrown if an operation cannot proceed as there are still unmerged
-    entries in the cache."""
-
-
-class HookExecutionError(CommandError):
-    """Thrown if a hook exits with a non-zero exit code.
-
-    This provides access to the exit code and the string returned via standard output.
-    """
-
-    def __init__(
-        self,
-        command: Union[List[str], Tuple[str, ...], str],
-        status: Union[str, int, None, Exception],
-        stderr: Union[bytes, str, None] = None,
-        stdout: Union[bytes, str, None] = None,
-    ) -> None:
-        super().__init__(command, status, stderr, stdout)
-        self._msg = "Hook('%s') failed%s"
-
-
-class RepositoryDirtyError(GitError):
-    """Thrown whenever an operation on a repository fails as it has uncommitted changes
-    that would be overwritten."""
-
-    def __init__(self, repo: "Repo", message: str) -> None:
-        self.repo = repo
-        self.message = message
-
-    def __str__(self) -> str:
-        return "Operation cannot be performed on %r: %s" % (self.repo, self.message)

ILYA/Lib/site-packages/git/index/__init__.py

@@ -1,16 +0,0 @@
-# This module is part of GitPython and is released under the
-# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
-
-"""Initialize the index package."""
-
-__all__ = [
-    "BaseIndexEntry",
-    "BlobFilter",
-    "CheckoutError",
-    "IndexEntry",
-    "IndexFile",
-    "StageType",
-]
-
-from .base import CheckoutError, IndexFile
-from .typ import BaseIndexEntry, BlobFilter, IndexEntry, StageType

ILYA/Lib/site-packages/git/index/base.py

@@ -1,1518 +0,0 @@
-# Copyright (C) 2008, 2009 Michael Trier ([email protected]) and contributors
-#
-# This module is part of GitPython and is released under the
-# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
-
-"""Module containing :class:`IndexFile`, an Index implementation facilitating all kinds
-of index manipulations such as querying and merging."""
-
-__all__ = ["IndexFile", "CheckoutError", "StageType"]
-
-import contextlib
-import datetime
-import glob
-from io import BytesIO
-import os
-import os.path as osp
-from stat import S_ISLNK
-import subprocess
-import sys
-import tempfile
-
-from gitdb.base import IStream
-from gitdb.db import MemoryDB
-
-from git.compat import defenc, force_bytes
-import git.diff as git_diff
-from git.exc import CheckoutError, GitCommandError, GitError, InvalidGitRepositoryError
-from git.objects import Blob, Commit, Object, Submodule, Tree
-from git.objects.util import Serializable
-from git.util import (
-    LazyMixin,
-    LockedFD,
-    join_path_native,
-    file_contents_ro,
-    to_native_path_linux,
-    unbare_repo,
-    to_bin_sha,
-)
-
-from .fun import (
-    S_IFGITLINK,
-    aggressive_tree_merge,
-    entry_key,
-    read_cache,
-    run_commit_hook,
-    stat_mode_to_index_mode,
-    write_cache,
-    write_tree_from_cache,
-)
-from .typ import BaseIndexEntry, IndexEntry, StageType
-from .util import TemporaryFileSwap, post_clear_cache, default_index, git_working_dir
-
-# typing -----------------------------------------------------------------------------
-
-from typing import (
-    Any,
-    BinaryIO,
-    Callable,
-    Dict,
-    Generator,
-    IO,
-    Iterable,
-    Iterator,
-    List,
-    NoReturn,
-    Sequence,
-    TYPE_CHECKING,
-    Tuple,
-    Union,
-)
-
-from git.types import Literal, PathLike
-
-if TYPE_CHECKING:
-    from subprocess import Popen
-
-    from git.refs.reference import Reference
-    from git.repo import Repo
-    from git.util import Actor
-
-
-Treeish = Union[Tree, Commit, str, bytes]
-
-# ------------------------------------------------------------------------------------
-
-
-@contextlib.contextmanager
-def _named_temporary_file_for_subprocess(directory: PathLike) -> Generator[str, None, None]:
-    """Create a named temporary file git subprocesses can open, deleting it afterward.
-
-    :param directory:
-        The directory in which the file is created.
-
-    :return:
-        A context manager object that creates the file and provides its name on entry,
-        and deletes it on exit.
-    """
-    if sys.platform == "win32":
-        fd, name = tempfile.mkstemp(dir=directory)
-        os.close(fd)
-        try:
-            yield name
-        finally:
-            os.remove(name)
-    else:
-        with tempfile.NamedTemporaryFile(dir=directory) as ctx:
-            yield ctx.name
-
-
-class IndexFile(LazyMixin, git_diff.Diffable, Serializable):
-    """An Index that can be manipulated using a native implementation in order to save
-    git command function calls wherever possible.
-
-    This provides custom merging facilities allowing to merge without actually changing
-    your index or your working tree. This way you can perform your own test merges based
-    on the index only without having to deal with the working copy. This is useful in
-    case of partial working trees.
-
-    Entries:
-
-        The index contains an entries dict whose keys are tuples of type
-        :class:`~git.index.typ.IndexEntry` to facilitate access.
-
-        You may read the entries dict or manipulate it using IndexEntry instance, i.e.::
-
-            index.entries[index.entry_key(index_entry_instance)] = index_entry_instance
-
-    Make sure you use :meth:`index.write() <write>` once you are done manipulating the
-    index directly before operating on it using the git command.
-    """
-
-    __slots__ = ("repo", "version", "entries", "_extension_data", "_file_path")
-
-    _VERSION = 2
-    """The latest version we support."""
-
-    S_IFGITLINK = S_IFGITLINK
-    """Flags for a submodule."""
-
-    def __init__(self, repo: "Repo", file_path: Union[PathLike, None] = None) -> None:
-        """Initialize this Index instance, optionally from the given `file_path`.
-
-        If no `file_path` is given, we will be created from the current index file.
-
-        If a stream is not given, the stream will be initialized from the current
-        repository's index on demand.
-        """
-        self.repo = repo
-        self.version = self._VERSION
-        self._extension_data = b""
-        self._file_path: PathLike = file_path or self._index_path()
-
-    def _set_cache_(self, attr: str) -> None:
-        if attr == "entries":
-            try:
-                fd = os.open(self._file_path, os.O_RDONLY)
-            except OSError:
-                # In new repositories, there may be no index, which means we are empty.
-                self.entries: Dict[Tuple[PathLike, StageType], IndexEntry] = {}
-                return
-            # END exception handling
-
-            try:
-                stream = file_contents_ro(fd, stream=True, allow_mmap=True)
-            finally:
-                os.close(fd)
-
-            self._deserialize(stream)
-        else:
-            super()._set_cache_(attr)
-
-    def _index_path(self) -> PathLike:
-        if self.repo.git_dir:
-            return join_path_native(self.repo.git_dir, "index")
-        else:
-            raise GitCommandError("No git directory given to join index path")
-
-    @property
-    def path(self) -> PathLike:
-        """:return: Path to the index file we are representing"""
-        return self._file_path
-
-    def _delete_entries_cache(self) -> None:
-        """Safely clear the entries cache so it can be recreated."""
-        try:
-            del self.entries
-        except AttributeError:
-            # It failed in Python 2.6.5 with AttributeError.
-            # FIXME: Look into whether we can just remove this except clause now.
-            pass
-        # END exception handling
-
-    # { Serializable Interface
-
-    def _deserialize(self, stream: IO) -> "IndexFile":
-        """Initialize this instance with index values read from the given stream."""
-        self.version, self.entries, self._extension_data, _conten_sha = read_cache(stream)
-        return self
-
-    def _entries_sorted(self) -> List[IndexEntry]:
-        """:return: List of entries, in a sorted fashion, first by path, then by stage"""
-        return sorted(self.entries.values(), key=lambda e: (e.path, e.stage))
-
-    def _serialize(self, stream: IO, ignore_extension_data: bool = False) -> "IndexFile":
-        entries = self._entries_sorted()
-        extension_data = self._extension_data  # type: Union[None, bytes]
-        if ignore_extension_data:
-            extension_data = None
-        write_cache(entries, stream, extension_data)
-        return self
-
-    # } END serializable interface
-
-    def write(
-        self,
-        file_path: Union[None, PathLike] = None,
-        ignore_extension_data: bool = False,
-    ) -> None:
-        """Write the current state to our file path or to the given one.
-
-        :param file_path:
-            If ``None``, we will write to our stored file path from which we have been
-            initialized. Otherwise we write to the given file path. Please note that
-            this will change the `file_path` of this index to the one you gave.
-
-        :param ignore_extension_data:
-            If ``True``, the TREE type extension data read in the index will not be
-            written to disk. NOTE that no extension data is actually written. Use this
-            if you have altered the index and would like to use
-            :manpage:`git-write-tree(1)` afterwards to create a tree representing your
-            written changes. If this data is present in the written index,
-            :manpage:`git-write-tree(1)` will instead write the stored/cached tree.
-            Alternatively, use :meth:`write_tree` to handle this case automatically.
-        """
-        # Make sure we have our entries read before getting a write lock.
-        # Otherwise it would be done when streaming.
-        # This can happen if one doesn't change the index, but writes it right away.
-        self.entries  # noqa: B018
-        lfd = LockedFD(file_path or self._file_path)
-        stream = lfd.open(write=True, stream=True)
-
-        try:
-            self._serialize(stream, ignore_extension_data)
-        except BaseException:
-            lfd.rollback()
-            raise
-
-        lfd.commit()
-
-        # Make sure we represent what we have written.
-        if file_path is not None:
-            self._file_path = file_path
-
-    @post_clear_cache
-    @default_index
-    def merge_tree(self, rhs: Treeish, base: Union[None, Treeish] = None) -> "IndexFile":
-        """Merge the given `rhs` treeish into the current index, possibly taking
-        a common base treeish into account.
-
-        As opposed to the :func:`from_tree` method, this allows you to use an already
-        existing tree as the left side of the merge.
-
-        :param rhs:
-            Treeish reference pointing to the 'other' side of the merge.
-
-        :param base:
-            Optional treeish reference pointing to the common base of `rhs` and this
-            index which equals lhs.
-
-        :return:
-            self (containing the merge and possibly unmerged entries in case of
-            conflicts)
-
-        :raise git.exc.GitCommandError:
-            If there is a merge conflict. The error will be raised at the first
-            conflicting path. If you want to have proper merge resolution to be done by
-            yourself, you have to commit the changed index (or make a valid tree from
-            it) and retry with a three-way :meth:`index.from_tree <from_tree>` call.
-        """
-        # -i : ignore working tree status
-        # --aggressive : handle more merge cases
-        # -m : do an actual merge
-        args: List[Union[Treeish, str]] = ["--aggressive", "-i", "-m"]
-        if base is not None:
-            args.append(base)
-        args.append(rhs)
-
-        self.repo.git.read_tree(args)
-        return self
-
-    @classmethod
-    def new(cls, repo: "Repo", *tree_sha: Union[str, Tree]) -> "IndexFile":
-        """Merge the given treeish revisions into a new index which is returned.
-
-        This method behaves like ``git-read-tree --aggressive`` when doing the merge.
-
-        :param repo:
-            The repository treeish are located in.
-
-        :param tree_sha:
-            20 byte or 40 byte tree sha or tree objects.
-
-        :return:
-            New :class:`IndexFile` instance. Its path will be undefined.
-            If you intend to write such a merged Index, supply an alternate
-            ``file_path`` to its :meth:`write` method.
-        """
-        tree_sha_bytes: List[bytes] = [to_bin_sha(str(t)) for t in tree_sha]
-        base_entries = aggressive_tree_merge(repo.odb, tree_sha_bytes)
-
-        inst = cls(repo)
-        # Convert to entries dict.
-        entries: Dict[Tuple[PathLike, int], IndexEntry] = dict(
-            zip(
-                ((e.path, e.stage) for e in base_entries),
-                (IndexEntry.from_base(e) for e in base_entries),
-            )
-        )
-
-        inst.entries = entries
-        return inst
-
-    @classmethod
-    def from_tree(cls, repo: "Repo", *treeish: Treeish, **kwargs: Any) -> "IndexFile":
-        R"""Merge the given treeish revisions into a new index which is returned.
-        The original index will remain unaltered.
-
-        :param repo:
-            The repository treeish are located in.
-
-        :param treeish:
-            One, two or three :class:`~git.objects.tree.Tree` objects,
-            :class:`~git.objects.commit.Commit`\s or 40 byte hexshas.
-
-            The result changes according to the amount of trees:
-
-            1. If 1 Tree is given, it will just be read into a new index.
-            2. If 2 Trees are given, they will be merged into a new index using a two
-               way merge algorithm. Tree 1 is the 'current' tree, tree 2 is the 'other'
-               one. It behaves like a fast-forward.
-            3. If 3 Trees are given, a 3-way merge will be performed with the first tree
-               being the common ancestor of tree 2 and tree 3. Tree 2 is the 'current'
-               tree, tree 3 is the 'other' one.
-
-        :param kwargs:
-            Additional arguments passed to :manpage:`git-read-tree(1)`.
-
-        :return:
-            New :class:`IndexFile` instance. It will point to a temporary index location
-            which does not exist anymore. If you intend to write such a merged Index,
-            supply an alternate ``file_path`` to its :meth:`write` method.
-
-        :note:
-            In the three-way merge case, ``--aggressive`` will be specified to
-            automatically resolve more cases in a commonly correct manner. Specify
-            ``trivial=True`` as a keyword argument to override that.
-
-            As the underlying :manpage:`git-read-tree(1)` command takes into account the
-            current index, it will be temporarily moved out of the way to prevent any
-            unexpected interference.
-        """
-        if len(treeish) == 0 or len(treeish) > 3:
-            raise ValueError("Please specify between 1 and 3 treeish, got %i" % len(treeish))
-
-        arg_list: List[Union[Treeish, str]] = []
-        # Ignore that the working tree and index possibly are out of date.
-        if len(treeish) > 1:
-            # Drop unmerged entries when reading our index and merging.
-            arg_list.append("--reset")
-            # Handle non-trivial cases the way a real merge does.
-            arg_list.append("--aggressive")
-        # END merge handling
-
-        # Create the temporary file in the .git directory to be sure renaming
-        # works - /tmp/ directories could be on another device.
-        with _named_temporary_file_for_subprocess(repo.git_dir) as tmp_index:
-            arg_list.append("--index-output=%s" % tmp_index)
-            arg_list.extend(treeish)
-
-            # Move the current index out of the way - otherwise the merge may fail as it
-            # considers existing entries. Moving it essentially clears the index.
-            # Unfortunately there is no 'soft' way to do it.
-            # The TemporaryFileSwap ensures the original file gets put back.
-            with TemporaryFileSwap(join_path_native(repo.git_dir, "index")):
-                repo.git.read_tree(*arg_list, **kwargs)
-                index = cls(repo, tmp_index)
-                index.entries  # noqa: B018 # Force it to read the file as we will delete the temp-file.
-                return index
-            # END index merge handling
-
-    # UTILITIES
-
-    @unbare_repo
-    def _iter_expand_paths(self: "IndexFile", paths: Sequence[PathLike]) -> Iterator[PathLike]:
-        """Expand the directories in list of paths to the corresponding paths
-        accordingly.
-
-        :note:
-            git will add items multiple times even if a glob overlapped with manually
-            specified paths or if paths where specified multiple times - we respect that
-            and do not prune.
-        """
-
-        def raise_exc(e: Exception) -> NoReturn:
-            raise e
-
-        r = str(self.repo.working_tree_dir)
-        rs = r + os.sep
-        for path in paths:
-            abs_path = str(path)
-            if not osp.isabs(abs_path):
-                abs_path = osp.join(r, path)
-            # END make absolute path
-
-            try:
-                st = os.lstat(abs_path)  # Handles non-symlinks as well.
-            except OSError:
-                # The lstat call may fail as the path may contain globs as well.
-                pass
-            else:
-                if S_ISLNK(st.st_mode):
-                    yield abs_path.replace(rs, "")
-                    continue
-            # END check symlink
-
-            # If the path is not already pointing to an existing file, resolve globs if possible.
-            if not os.path.exists(abs_path) and ("?" in abs_path or "*" in abs_path or "[" in abs_path):
-                resolved_paths = glob.glob(abs_path)
-                # not abs_path in resolved_paths:
-                #   A glob() resolving to the same path we are feeding it with is a
-                #   glob() that failed to resolve. If we continued calling ourselves
-                #   we'd endlessly recurse. If the condition below evaluates to true
-                #   then we are likely dealing with a file whose name contains wildcard
-                #   characters.
-                if abs_path not in resolved_paths:
-                    for f in self._iter_expand_paths(glob.glob(abs_path)):
-                        yield str(f).replace(rs, "")
-                    continue
-            # END glob handling
-            try:
-                for root, _dirs, files in os.walk(abs_path, onerror=raise_exc):
-                    for rela_file in files:
-                        # Add relative paths only.
-                        yield osp.join(root.replace(rs, ""), rela_file)
-                    # END for each file in subdir
-                # END for each subdirectory
-            except OSError:
-                # It was a file or something that could not be iterated.
-                yield abs_path.replace(rs, "")
-            # END path exception handling
-        # END for each path
-
-    def _write_path_to_stdin(
-        self,
-        proc: "Popen",
-        filepath: PathLike,
-        item: PathLike,
-        fmakeexc: Callable[..., GitError],
-        fprogress: Callable[[PathLike, bool, PathLike], None],
-        read_from_stdout: bool = True,
-    ) -> Union[None, str]:
-        """Write path to ``proc.stdin`` and make sure it processes the item, including
-        progress.
-
-        :return:
-            stdout string
-
-        :param read_from_stdout:
-            If ``True``, ``proc.stdout`` will be read after the item was sent to stdin.
-            In that case, it will return ``None``.
-
-        :note:
-            There is a bug in :manpage:`git-update-index(1)` that prevents it from
-            sending reports just in time. This is why we have a version that tries to
-            read stdout and one which doesn't. In fact, the stdout is not important as
-            the piped-in files are processed anyway and just in time.
-
-        :note:
-            Newlines are essential here, git's behaviour is somewhat inconsistent on
-            this depending on the version, hence we try our best to deal with newlines
-            carefully. Usually the last newline will not be sent, instead we will close
-            stdin to break the pipe.
-        """
-        fprogress(filepath, False, item)
-        rval: Union[None, str] = None
-
-        if proc.stdin is not None:
-            try:
-                proc.stdin.write(("%s\n" % filepath).encode(defenc))
-            except IOError as e:
-                # Pipe broke, usually because some error happened.
-                raise fmakeexc() from e
-            # END write exception handling
-            proc.stdin.flush()
-
-        if read_from_stdout and proc.stdout is not None:
-            rval = proc.stdout.readline().strip()
-        fprogress(filepath, True, item)
-        return rval
-
-    def iter_blobs(
-        self, predicate: Callable[[Tuple[StageType, Blob]], bool] = lambda t: True
-    ) -> Iterator[Tuple[StageType, Blob]]:
-        """
-        :return:
-            Iterator yielding tuples of :class:`~git.objects.blob.Blob` objects and
-            stages, tuple(stage, Blob).
-
-        :param predicate:
-            Function(t) returning ``True`` if tuple(stage, Blob) should be yielded by
-            the iterator. A default filter, the `~git.index.typ.BlobFilter`, allows you
-            to yield blobs only if they match a given list of paths.
-        """
-        for entry in self.entries.values():
-            blob = entry.to_blob(self.repo)
-            blob.size = entry.size
-            output = (entry.stage, blob)
-            if predicate(output):
-                yield output
-        # END for each entry
-
-    def unmerged_blobs(self) -> Dict[PathLike, List[Tuple[StageType, Blob]]]:
-        """
-        :return:
-            Dict(path : list(tuple(stage, Blob, ...))), being a dictionary associating a
-            path in the index with a list containing sorted stage/blob pairs.
-
-        :note:
-            Blobs that have been removed in one side simply do not exist in the given
-            stage. That is, a file removed on the 'other' branch whose entries are at
-            stage 3 will not have a stage 3 entry.
-        """
-        is_unmerged_blob = lambda t: t[0] != 0
-        path_map: Dict[PathLike, List[Tuple[StageType, Blob]]] = {}
-        for stage, blob in self.iter_blobs(is_unmerged_blob):
-            path_map.setdefault(blob.path, []).append((stage, blob))
-        # END for each unmerged blob
-        for line in path_map.values():
-            line.sort()
-
-        return path_map
-
-    @classmethod
-    def entry_key(cls, *entry: Union[BaseIndexEntry, PathLike, StageType]) -> Tuple[PathLike, StageType]:
-        return entry_key(*entry)
-
-    def resolve_blobs(self, iter_blobs: Iterator[Blob]) -> "IndexFile":
-        """Resolve the blobs given in blob iterator.
-
-        This will effectively remove the index entries of the respective path at all
-        non-null stages and add the given blob as new stage null blob.
-
-        For each path there may only be one blob, otherwise a :exc:`ValueError` will be
-        raised claiming the path is already at stage 0.
-
-        :raise ValueError:
-            If one of the blobs already existed at stage 0.
-
-        :return:
-            self
-
-        :note:
-            You will have to write the index manually once you are done, i.e.
-            ``index.resolve_blobs(blobs).write()``.
-        """
-        for blob in iter_blobs:
-            stage_null_key = (blob.path, 0)
-            if stage_null_key in self.entries:
-                raise ValueError("Path %r already exists at stage 0" % str(blob.path))
-            # END assert blob is not stage 0 already
-
-            # Delete all possible stages.
-            for stage in (1, 2, 3):
-                try:
-                    del self.entries[(blob.path, stage)]
-                except KeyError:
-                    pass
-                # END ignore key errors
-            # END for each possible stage
-
-            self.entries[stage_null_key] = IndexEntry.from_blob(blob)
-        # END for each blob
-
-        return self
-
-    def update(self) -> "IndexFile":
-        """Reread the contents of our index file, discarding all cached information
-        we might have.
-
-        :note:
-            This is a possibly dangerous operations as it will discard your changes to
-            :attr:`index.entries <entries>`.
-
-        :return:
-            self
-        """
-        self._delete_entries_cache()
-        # Allows to lazily reread on demand.
-        return self
-
-    def write_tree(self) -> Tree:
-        """Write this index to a corresponding :class:`~git.objects.tree.Tree` object
-        into the repository's object database and return it.
-
-        :return:
-            :class:`~git.objects.tree.Tree` object representing this index.
-
-        :note:
-            The tree will be written even if one or more objects the tree refers to does
-            not yet exist in the object database. This could happen if you added entries
-            to the index directly.
-
-        :raise ValueError:
-            If there are no entries in the cache.
-
-        :raise git.exc.UnmergedEntriesError:
-        """
-        # We obtain no lock as we just flush our contents to disk as tree.
-        # If we are a new index, the entries access will load our data accordingly.
-        mdb = MemoryDB()
-        entries = self._entries_sorted()
-        binsha, tree_items = write_tree_from_cache(entries, mdb, slice(0, len(entries)))
-
-        # Copy changed trees only.
-        mdb.stream_copy(mdb.sha_iter(), self.repo.odb)
-
-        # Note: Additional deserialization could be saved if write_tree_from_cache would
-        # return sorted tree entries.
-        root_tree = Tree(self.repo, binsha, path="")
-        root_tree._cache = tree_items
-        return root_tree
-
-    def _process_diff_args(
-        self,
-        args: List[Union[PathLike, "git_diff.Diffable"]],
-    ) -> List[Union[PathLike, "git_diff.Diffable"]]:
-        try:
-            args.pop(args.index(self))
-        except IndexError:
-            pass
-        # END remove self
-        return args
-
-    def _to_relative_path(self, path: PathLike) -> PathLike:
-        """
-        :return:
-            Version of path relative to our git directory or raise :exc:`ValueError` if
-            it is not within our git directory.
-
-        :raise ValueError:
-        """
-        if not osp.isabs(path):
-            return path
-        if self.repo.bare:
-            raise InvalidGitRepositoryError("require non-bare repository")
-        if not str(path).startswith(str(self.repo.working_tree_dir)):
-            raise ValueError("Absolute path %r is not in git repository at %r" % (path, self.repo.working_tree_dir))
-        return os.path.relpath(path, self.repo.working_tree_dir)
-
-    def _preprocess_add_items(
-        self, items: Sequence[Union[PathLike, Blob, BaseIndexEntry, "Submodule"]]
-    ) -> Tuple[List[PathLike], List[BaseIndexEntry]]:
-        """Split the items into two lists of path strings and BaseEntries."""
-        paths = []
-        entries = []
-        # if it is a string put in list
-        if isinstance(items, (str, os.PathLike)):
-            items = [items]
-
-        for item in items:
-            if isinstance(item, (str, os.PathLike)):
-                paths.append(self._to_relative_path(item))
-            elif isinstance(item, (Blob, Submodule)):
-                entries.append(BaseIndexEntry.from_blob(item))
-            elif isinstance(item, BaseIndexEntry):
-                entries.append(item)
-            else:
-                raise TypeError("Invalid Type: %r" % item)
-        # END for each item
-        return paths, entries
-
-    def _store_path(self, filepath: PathLike, fprogress: Callable) -> BaseIndexEntry:
-        """Store file at filepath in the database and return the base index entry.
-
-        :note:
-            This needs the :func:`~git.index.util.git_working_dir` decorator active!
-            This must be ensured in the calling code.
-        """
-        st = os.lstat(filepath)  # Handles non-symlinks as well.
-        if S_ISLNK(st.st_mode):
-            # In PY3, readlink is a string, but we need bytes.
-            # In PY2, it was just OS encoded bytes, we assumed UTF-8.
-            open_stream: Callable[[], BinaryIO] = lambda: BytesIO(force_bytes(os.readlink(filepath), encoding=defenc))
-        else:
-            open_stream = lambda: open(filepath, "rb")
-        with open_stream() as stream:
-            fprogress(filepath, False, filepath)
-            istream = self.repo.odb.store(IStream(Blob.type, st.st_size, stream))
-            fprogress(filepath, True, filepath)
-        return BaseIndexEntry(
-            (
-                stat_mode_to_index_mode(st.st_mode),
-                istream.binsha,
-                0,
-                to_native_path_linux(filepath),
-            )
-        )
-
-    @unbare_repo
-    @git_working_dir
-    def _entries_for_paths(
-        self,
-        paths: List[str],
-        path_rewriter: Union[Callable, None],
-        fprogress: Callable,
-        entries: List[BaseIndexEntry],
-    ) -> List[BaseIndexEntry]:
-        entries_added: List[BaseIndexEntry] = []
-        if path_rewriter:
-            for path in paths:
-                if osp.isabs(path):
-                    abspath = path
-                    gitrelative_path = path[len(str(self.repo.working_tree_dir)) + 1 :]
-                else:
-                    gitrelative_path = path
-                    if self.repo.working_tree_dir:
-                        abspath = osp.join(self.repo.working_tree_dir, gitrelative_path)
-                # END obtain relative and absolute paths
-
-                blob = Blob(
-                    self.repo,
-                    Blob.NULL_BIN_SHA,
-                    stat_mode_to_index_mode(os.stat(abspath).st_mode),
-                    to_native_path_linux(gitrelative_path),
-                )
-                # TODO: variable undefined
-                entries.append(BaseIndexEntry.from_blob(blob))
-            # END for each path
-            del paths[:]
-        # END rewrite paths
-
-        # HANDLE PATHS
-        assert len(entries_added) == 0
-        for filepath in self._iter_expand_paths(paths):
-            entries_added.append(self._store_path(filepath, fprogress))
-        # END for each filepath
-        # END path handling
-        return entries_added
-
-    def add(
-        self,
-        items: Sequence[Union[PathLike, Blob, BaseIndexEntry, "Submodule"]],
-        force: bool = True,
-        fprogress: Callable = lambda *args: None,
-        path_rewriter: Union[Callable[..., PathLike], None] = None,
-        write: bool = True,
-        write_extension_data: bool = False,
-    ) -> List[BaseIndexEntry]:
-        R"""Add files from the working tree, specific blobs, or
-        :class:`~git.index.typ.BaseIndexEntry`\s to the index.
-
-        :param items:
-            Multiple types of items are supported, types can be mixed within one call.
-            Different types imply a different handling. File paths may generally be
-            relative or absolute.
-
-            - path string
-
-                Strings denote a relative or absolute path into the repository pointing
-                to an existing file, e.g., ``CHANGES``, `lib/myfile.ext``,
-                ``/home/gitrepo/lib/myfile.ext``.
-
-                Absolute paths must start with working tree directory of this index's
-                repository to be considered valid. For example, if it was initialized
-                with a non-normalized path, like ``/root/repo/../repo``, absolute paths
-                to be added must start with ``/root/repo/../repo``.
-
-                Paths provided like this must exist. When added, they will be written
-                into the object database.
-
-                PathStrings may contain globs, such as ``lib/__init__*``. Or they can be
-                directories like ``lib``, which will add all the files within the
-                directory and subdirectories.
-
-                This equals a straight :manpage:`git-add(1)`.
-
-                They are added at stage 0.
-
-            - :class:~`git.objects.blob.Blob` or
-              :class:`~git.objects.submodule.base.Submodule` object
-
-                Blobs are added as they are assuming a valid mode is set.
-
-                The file they refer to may or may not exist in the file system, but must
-                be a path relative to our repository.
-
-                If their sha is null (40*0), their path must exist in the file system
-                relative to the git repository as an object will be created from the
-                data at the path.
-
-                The handling now very much equals the way string paths are processed,
-                except that the mode you have set will be kept. This allows you to
-                create symlinks by settings the mode respectively and writing the target
-                of the symlink directly into the file. This equals a default Linux
-                symlink which is not dereferenced automatically, except that it can be
-                created on filesystems not supporting it as well.
-
-                Please note that globs or directories are not allowed in
-                :class:`~git.objects.blob.Blob` objects.
-
-                They are added at stage 0.
-
-            - :class:`~git.index.typ.BaseIndexEntry` or type
-
-                Handling equals the one of :class:~`git.objects.blob.Blob` objects, but
-                the stage may be explicitly set. Please note that Index Entries require
-                binary sha's.
-
-        :param force:
-            **CURRENTLY INEFFECTIVE**
-            If ``True``, otherwise ignored or excluded files will be added anyway. As
-            opposed to the :manpage:`git-add(1)` command, we enable this flag by default
-            as the API user usually wants the item to be added even though they might be
-            excluded.
-
-        :param fprogress:
-            Function with signature ``f(path, done=False, item=item)`` called for each
-            path to be added, one time once it is about to be added where ``done=False``
-            and once after it was added where ``done=True``.
-
-            ``item`` is set to the actual item we handle, either a path or a
-            :class:`~git.index.typ.BaseIndexEntry`.
-
-            Please note that the processed path is not guaranteed to be present in the
-            index already as the index is currently being processed.
-
-        :param path_rewriter:
-            Function, with signature ``(string) func(BaseIndexEntry)``, returning a path
-            for each passed entry which is the path to be actually recorded for the
-            object created from :attr:`entry.path <git.index.typ.BaseIndexEntry.path>`.
-            This allows you to write an index which is not identical to the layout of
-            the actual files on your hard-disk. If not ``None`` and `items` contain
-            plain paths, these paths will be converted to Entries beforehand and passed
-            to the path_rewriter. Please note that ``entry.path`` is relative to the git
-            repository.
-
-        :param write:
-            If ``True``, the index will be written once it was altered. Otherwise the
-            changes only exist in memory and are not available to git commands.
-
-        :param write_extension_data:
-            If ``True``, extension data will be written back to the index. This can lead
-            to issues in case it is containing the 'TREE' extension, which will cause
-            the :manpage:`git-commit(1)` command to write an old tree, instead of a new
-            one representing the now changed index.
-
-            This doesn't matter if you use :meth:`IndexFile.commit`, which ignores the
-            'TREE' extension altogether. You should set it to ``True`` if you intend to
-            use :meth:`IndexFile.commit` exclusively while maintaining support for
-            third-party extensions. Besides that, you can usually safely ignore the
-            built-in extensions when using GitPython on repositories that are not
-            handled manually at all.
-
-            All current built-in extensions are listed here:
-            https://git-scm.com/docs/index-format
-
-        :return:
-            List of :class:`~git.index.typ.BaseIndexEntry`\s representing the entries
-            just actually added.
-
-        :raise OSError:
-            If a supplied path did not exist. Please note that
-            :class:`~git.index.typ.BaseIndexEntry` objects that do not have a null sha
-            will be added even if their paths do not exist.
-        """
-        # Sort the entries into strings and Entries.
-        # Blobs are converted to entries automatically.
-        # Paths can be git-added. For everything else we use git-update-index.
-        paths, entries = self._preprocess_add_items(items)
-        entries_added: List[BaseIndexEntry] = []
-        # This code needs a working tree, so we try not to run it unless required.
-        # That way, we are OK on a bare repository as well.
-        # If there are no paths, the rewriter has nothing to do either.
-        if paths:
-            entries_added.extend(self._entries_for_paths(paths, path_rewriter, fprogress, entries))
-
-        # HANDLE ENTRIES
-        if entries:
-            null_mode_entries = [e for e in entries if e.mode == 0]
-            if null_mode_entries:
-                raise ValueError(
-                    "At least one Entry has a null-mode - please use index.remove to remove files for clarity"
-                )
-            # END null mode should be remove
-
-            # HANDLE ENTRY OBJECT CREATION
-            # Create objects if required, otherwise go with the existing shas.
-            null_entries_indices = [i for i, e in enumerate(entries) if e.binsha == Object.NULL_BIN_SHA]
-            if null_entries_indices:
-
-                @git_working_dir
-                def handle_null_entries(self: "IndexFile") -> None:
-                    for ei in null_entries_indices:
-                        null_entry = entries[ei]
-                        new_entry = self._store_path(null_entry.path, fprogress)
-
-                        # Update null entry.
-                        entries[ei] = BaseIndexEntry(
-                            (
-                                null_entry.mode,
-                                new_entry.binsha,
-                                null_entry.stage,
-                                null_entry.path,
-                            )
-                        )
-                    # END for each entry index
-
-                # END closure
-
-                handle_null_entries(self)
-            # END null_entry handling
-
-            # REWRITE PATHS
-            # If we have to rewrite the entries, do so now, after we have generated all
-            # object sha's.
-            if path_rewriter:
-                for i, e in enumerate(entries):
-                    entries[i] = BaseIndexEntry((e.mode, e.binsha, e.stage, path_rewriter(e)))
-                # END for each entry
-            # END handle path rewriting
-
-            # Just go through the remaining entries and provide progress info.
-            for i, entry in enumerate(entries):
-                progress_sent = i in null_entries_indices
-                if not progress_sent:
-                    fprogress(entry.path, False, entry)
-                    fprogress(entry.path, True, entry)
-                # END handle progress
-            # END for each entry
-            entries_added.extend(entries)
-        # END if there are base entries
-
-        # FINALIZE
-        # Add the new entries to this instance.
-        for entry in entries_added:
-            self.entries[(entry.path, 0)] = IndexEntry.from_base(entry)
-
-        if write:
-            self.write(ignore_extension_data=not write_extension_data)
-        # END handle write
-
-        return entries_added
-
-    def _items_to_rela_paths(
-        self,
-        items: Union[PathLike, Sequence[Union[PathLike, BaseIndexEntry, Blob, Submodule]]],
-    ) -> List[PathLike]:
-        """Returns a list of repo-relative paths from the given items which
-        may be absolute or relative paths, entries or blobs."""
-        paths = []
-        # If string, put in list.
-        if isinstance(items, (str, os.PathLike)):
-            items = [items]
-
-        for item in items:
-            if isinstance(item, (BaseIndexEntry, (Blob, Submodule))):
-                paths.append(self._to_relative_path(item.path))
-            elif isinstance(item, (str, os.PathLike)):
-                paths.append(self._to_relative_path(item))
-            else:
-                raise TypeError("Invalid item type: %r" % item)
-        # END for each item
-        return paths
-
-    @post_clear_cache
-    @default_index
-    def remove(
-        self,
-        items: Sequence[Union[PathLike, Blob, BaseIndexEntry, "Submodule"]],
-        working_tree: bool = False,
-        **kwargs: Any,
-    ) -> List[str]:
-        R"""Remove the given items from the index and optionally from the working tree
-        as well.
-
-        :param items:
-            Multiple types of items are supported which may be be freely mixed.
-
-            - path string
-
-                Remove the given path at all stages. If it is a directory, you must
-                specify the ``r=True`` keyword argument to remove all file entries below
-                it. If absolute paths are given, they will be converted to a path
-                relative to the git repository directory containing the working tree
-
-                The path string may include globs, such as ``*.c``.
-
-            - :class:~`git.objects.blob.Blob` object
-
-                Only the path portion is used in this case.
-
-            - :class:`~git.index.typ.BaseIndexEntry` or compatible type
-
-                The only relevant information here is the path. The stage is ignored.
-
-        :param working_tree:
-            If ``True``, the entry will also be removed from the working tree,
-            physically removing the respective file. This may fail if there are
-            uncommitted changes in it.
-
-        :param kwargs:
-            Additional keyword arguments to be passed to :manpage:`git-rm(1)`, such as
-            ``r`` to allow recursive removal.
-
-        :return:
-            List(path_string, ...) list of repository relative paths that have been
-            removed effectively.
-
-            This is interesting to know in case you have provided a directory or globs.
-            Paths are relative to the repository.
-        """
-        args = []
-        if not working_tree:
-            args.append("--cached")
-        args.append("--")
-
-        # Preprocess paths.
-        paths = self._items_to_rela_paths(items)
-        removed_paths = self.repo.git.rm(args, paths, **kwargs).splitlines()
-
-        # Process output to gain proper paths.
-        # rm 'path'
-        return [p[4:-1] for p in removed_paths]
-
-    @post_clear_cache
-    @default_index
-    def move(
-        self,
-        items: Sequence[Union[PathLike, Blob, BaseIndexEntry, "Submodule"]],
-        skip_errors: bool = False,
-        **kwargs: Any,
-    ) -> List[Tuple[str, str]]:
-        """Rename/move the items, whereas the last item is considered the destination of
-        the move operation.
-
-        If the destination is a file, the first item (of two) must be a file as well.
-
-        If the destination is a directory, it may be preceded by one or more directories
-        or files.
-
-        The working tree will be affected in non-bare repositories.
-
-        :param items:
-            Multiple types of items are supported, please see the :meth:`remove` method
-            for reference.
-
-        :param skip_errors:
-            If ``True``, errors such as ones resulting from missing source files will be
-            skipped.
-
-        :param kwargs:
-            Additional arguments you would like to pass to :manpage:`git-mv(1)`, such as
-            ``dry_run`` or ``force``.
-
-        :return:
-            List(tuple(source_path_string, destination_path_string), ...)
-
-            A list of pairs, containing the source file moved as well as its actual
-            destination. Relative to the repository root.
-
-        :raise ValueError:
-            If only one item was given.
-
-        :raise git.exc.GitCommandError:
-            If git could not handle your request.
-        """
-        args = []
-        if skip_errors:
-            args.append("-k")
-
-        paths = self._items_to_rela_paths(items)
-        if len(paths) < 2:
-            raise ValueError("Please provide at least one source and one destination of the move operation")
-
-        was_dry_run = kwargs.pop("dry_run", kwargs.pop("n", None))
-        kwargs["dry_run"] = True
-
-        # First execute rename in dry run so the command tells us what it actually does
-        # (for later output).
-        out = []
-        mvlines = self.repo.git.mv(args, paths, **kwargs).splitlines()
-
-        # Parse result - first 0:n/2 lines are 'checking ', the remaining ones are the
-        # 'renaming' ones which we parse.
-        for ln in range(int(len(mvlines) / 2), len(mvlines)):
-            tokens = mvlines[ln].split(" to ")
-            assert len(tokens) == 2, "Too many tokens in %s" % mvlines[ln]
-
-            # [0] = Renaming x
-            # [1] = y
-            out.append((tokens[0][9:], tokens[1]))
-        # END for each line to parse
-
-        # Either prepare for the real run, or output the dry-run result.
-        if was_dry_run:
-            return out
-        # END handle dry run
-
-        # Now apply the actual operation.
-        kwargs.pop("dry_run")
-        self.repo.git.mv(args, paths, **kwargs)
-
-        return out
-
-    def commit(
-        self,
-        message: str,
-        parent_commits: Union[List[Commit], None] = None,
-        head: bool = True,
-        author: Union[None, "Actor"] = None,
-        committer: Union[None, "Actor"] = None,
-        author_date: Union[datetime.datetime, str, None] = None,
-        commit_date: Union[datetime.datetime, str, None] = None,
-        skip_hooks: bool = False,
-    ) -> Commit:
-        """Commit the current default index file, creating a
-        :class:`~git.objects.commit.Commit` object.
-
-        For more information on the arguments, see
-        :meth:`Commit.create_from_tree <git.objects.commit.Commit.create_from_tree>`.
-
-        :note:
-            If you have manually altered the :attr:`entries` member of this instance,
-            don't forget to :meth:`write` your changes to disk beforehand.
-
-        :note:
-            Passing ``skip_hooks=True`` is the equivalent of using ``-n`` or
-            ``--no-verify`` on the command line.
-
-        :return:
-            :class:`~git.objects.commit.Commit` object representing the new commit
-        """
-        if not skip_hooks:
-            run_commit_hook("pre-commit", self)
-
-            self._write_commit_editmsg(message)
-            run_commit_hook("commit-msg", self, self._commit_editmsg_filepath())
-            message = self._read_commit_editmsg()
-            self._remove_commit_editmsg()
-        tree = self.write_tree()
-        rval = Commit.create_from_tree(
-            self.repo,
-            tree,
-            message,
-            parent_commits,
-            head,
-            author=author,
-            committer=committer,
-            author_date=author_date,
-            commit_date=commit_date,
-        )
-        if not skip_hooks:
-            run_commit_hook("post-commit", self)
-        return rval
-
-    def _write_commit_editmsg(self, message: str) -> None:
-        with open(self._commit_editmsg_filepath(), "wb") as commit_editmsg_file:
-            commit_editmsg_file.write(message.encode(defenc))
-
-    def _remove_commit_editmsg(self) -> None:
-        os.remove(self._commit_editmsg_filepath())
-
-    def _read_commit_editmsg(self) -> str:
-        with open(self._commit_editmsg_filepath(), "rb") as commit_editmsg_file:
-            return commit_editmsg_file.read().decode(defenc)
-
-    def _commit_editmsg_filepath(self) -> str:
-        return osp.join(self.repo.common_dir, "COMMIT_EDITMSG")
-
-    def _flush_stdin_and_wait(cls, proc: "Popen[bytes]", ignore_stdout: bool = False) -> bytes:
-        stdin_IO = proc.stdin
-        if stdin_IO:
-            stdin_IO.flush()
-            stdin_IO.close()
-
-        stdout = b""
-        if not ignore_stdout and proc.stdout:
-            stdout = proc.stdout.read()
-
-        if proc.stdout:
-            proc.stdout.close()
-            proc.wait()
-        return stdout
-
-    @default_index
-    def checkout(
-        self,
-        paths: Union[None, Iterable[PathLike]] = None,
-        force: bool = False,
-        fprogress: Callable = lambda *args: None,
-        **kwargs: Any,
-    ) -> Union[None, Iterator[PathLike], Sequence[PathLike]]:
-        """Check out the given paths or all files from the version known to the index
-        into the working tree.
-
-        :note:
-            Be sure you have written pending changes using the :meth:`write` method in
-            case you have altered the entries dictionary directly.
-
-        :param paths:
-            If ``None``, all paths in the index will be checked out.
-            Otherwise an iterable of relative or absolute paths or a single path
-            pointing to files or directories in the index is expected.
-
-        :param force:
-            If ``True``, existing files will be overwritten even if they contain local
-            modifications.
-            If ``False``, these will trigger a :exc:`~git.exc.CheckoutError`.
-
-        :param fprogress:
-            See :meth:`IndexFile.add` for signature and explanation.
-
-            The provided progress information will contain ``None`` as path and item if
-            no explicit paths are given. Otherwise progress information will be send
-            prior and after a file has been checked out.
-
-        :param kwargs:
-            Additional arguments to be passed to :manpage:`git-checkout-index(1)`.
-
-        :return:
-            Iterable yielding paths to files which have been checked out and are
-            guaranteed to match the version stored in the index.
-
-        :raise git.exc.CheckoutError:
-            * If at least one file failed to be checked out. This is a summary, hence it
-              will checkout as many files as it can anyway.
-            * If one of files or directories do not exist in the index (as opposed to
-              the original git command, which ignores them).
-
-        :raise git.exc.GitCommandError:
-            If error lines could not be parsed - this truly is an exceptional state.
-
-        :note:
-            The checkout is limited to checking out the files in the index. Files which
-            are not in the index anymore and exist in the working tree will not be
-            deleted. This behaviour is fundamentally different to ``head.checkout``,
-            i.e. if you want :manpage:`git-checkout(1)`-like behaviour, use
-            ``head.checkout`` instead of ``index.checkout``.
-        """
-        args = ["--index"]
-        if force:
-            args.append("--force")
-
-        failed_files = []
-        failed_reasons = []
-        unknown_lines = []
-
-        def handle_stderr(proc: "Popen[bytes]", iter_checked_out_files: Iterable[PathLike]) -> None:
-            stderr_IO = proc.stderr
-            if not stderr_IO:
-                return  # Return early if stderr empty.
-
-            stderr_bytes = stderr_IO.read()
-            # line contents:
-            stderr = stderr_bytes.decode(defenc)
-            # git-checkout-index: this already exists
-            endings = (
-                " already exists",
-                " is not in the cache",
-                " does not exist at stage",
-                " is unmerged",
-            )
-            for line in stderr.splitlines():
-                if not line.startswith("git checkout-index: ") and not line.startswith("git-checkout-index: "):
-                    is_a_dir = " is a directory"
-                    unlink_issue = "unable to unlink old '"
-                    already_exists_issue = " already exists, no checkout"  # created by entry.c:checkout_entry(...)
-                    if line.endswith(is_a_dir):
-                        failed_files.append(line[: -len(is_a_dir)])
-                        failed_reasons.append(is_a_dir)
-                    elif line.startswith(unlink_issue):
-                        failed_files.append(line[len(unlink_issue) : line.rfind("'")])
-                        failed_reasons.append(unlink_issue)
-                    elif line.endswith(already_exists_issue):
-                        failed_files.append(line[: -len(already_exists_issue)])
-                        failed_reasons.append(already_exists_issue)
-                    else:
-                        unknown_lines.append(line)
-                    continue
-                # END special lines parsing
-
-                for e in endings:
-                    if line.endswith(e):
-                        failed_files.append(line[20 : -len(e)])
-                        failed_reasons.append(e)
-                        break
-                    # END if ending matches
-                # END for each possible ending
-            # END for each line
-            if unknown_lines:
-                raise GitCommandError(("git-checkout-index",), 128, stderr)
-            if failed_files:
-                valid_files = list(set(iter_checked_out_files) - set(failed_files))
-                raise CheckoutError(
-                    "Some files could not be checked out from the index due to local modifications",
-                    failed_files,
-                    valid_files,
-                    failed_reasons,
-                )
-
-        # END stderr handler
-
-        if paths is None:
-            args.append("--all")
-            kwargs["as_process"] = 1
-            fprogress(None, False, None)
-            proc = self.repo.git.checkout_index(*args, **kwargs)
-            proc.wait()
-            fprogress(None, True, None)
-            rval_iter = (e.path for e in self.entries.values())
-            handle_stderr(proc, rval_iter)
-            return rval_iter
-        else:
-            if isinstance(paths, str):
-                paths = [paths]
-
-            # Make sure we have our entries loaded before we start checkout_index, which
-            # will hold a lock on it. We try to get the lock as well during our entries
-            # initialization.
-            self.entries  # noqa: B018
-
-            args.append("--stdin")
-            kwargs["as_process"] = True
-            kwargs["istream"] = subprocess.PIPE
-            proc = self.repo.git.checkout_index(args, **kwargs)
-            # FIXME: Reading from GIL!
-            make_exc = lambda: GitCommandError(("git-checkout-index",) + tuple(args), 128, proc.stderr.read())
-            checked_out_files: List[PathLike] = []
-
-            for path in paths:
-                co_path = to_native_path_linux(self._to_relative_path(path))
-                # If the item is not in the index, it could be a directory.
-                path_is_directory = False
-
-                try:
-                    self.entries[(co_path, 0)]
-                except KeyError:
-                    folder = str(co_path)
-                    if not folder.endswith("/"):
-                        folder += "/"
-                    for entry in self.entries.values():
-                        if str(entry.path).startswith(folder):
-                            p = entry.path
-                            self._write_path_to_stdin(proc, p, p, make_exc, fprogress, read_from_stdout=False)
-                            checked_out_files.append(p)
-                            path_is_directory = True
-                        # END if entry is in directory
-                    # END for each entry
-                # END path exception handlnig
-
-                if not path_is_directory:
-                    self._write_path_to_stdin(proc, co_path, path, make_exc, fprogress, read_from_stdout=False)
-                    checked_out_files.append(co_path)
-                # END path is a file
-            # END for each path
-            try:
-                self._flush_stdin_and_wait(proc, ignore_stdout=True)
-            except GitCommandError:
-                # Without parsing stdout we don't know what failed.
-                raise CheckoutError(  # noqa: B904
-                    "Some files could not be checked out from the index, probably because they didn't exist.",
-                    failed_files,
-                    [],
-                    failed_reasons,
-                )
-
-            handle_stderr(proc, checked_out_files)
-            return checked_out_files
-        # END paths handling
-
-    @default_index
-    def reset(
-        self,
-        commit: Union[Commit, "Reference", str] = "HEAD",
-        working_tree: bool = False,
-        paths: Union[None, Iterable[PathLike]] = None,
-        head: bool = False,
-        **kwargs: Any,
-    ) -> "IndexFile":
-        """Reset the index to reflect the tree at the given commit. This will not adjust
-        our HEAD reference by default, as opposed to
-        :meth:`HEAD.reset <git.refs.head.HEAD.reset>`.
-
-        :param commit:
-            Revision, :class:`~git.refs.reference.Reference` or
-            :class:`~git.objects.commit.Commit` specifying the commit we should
-            represent.
-
-            If you want to specify a tree only, use :meth:`IndexFile.from_tree` and
-            overwrite the default index.
-
-        :param working_tree:
-            If ``True``, the files in the working tree will reflect the changed index.
-            If ``False``, the working tree will not be touched.
-            Please note that changes to the working copy will be discarded without
-            warning!
-
-        :param head:
-            If ``True``, the head will be set to the given commit. This is ``False`` by
-            default, but if ``True``, this method behaves like
-            :meth:`HEAD.reset <git.refs.head.HEAD.reset>`.
-
-        :param paths:
-            If given as an iterable of absolute or repository-relative paths, only these
-            will be reset to their state at the given commit-ish.
-            The paths need to exist at the commit, otherwise an exception will be
-            raised.
-
-        :param kwargs:
-            Additional keyword arguments passed to :manpage:`git-reset(1)`.
-
-        :note:
-            :meth:`IndexFile.reset`, as opposed to
-            :meth:`HEAD.reset <git.refs.head.HEAD.reset>`, will not delete any files in
-            order to maintain a consistent working tree. Instead, it will just check out
-            the files according to their state in the index.
-            If you want :manpage:`git-reset(1)`-like behaviour, use
-            :meth:`HEAD.reset <git.refs.head.HEAD.reset>` instead.
-
-        :return:
-            self
-        """
-        # What we actually want to do is to merge the tree into our existing index,
-        # which is what git-read-tree does.
-        new_inst = type(self).from_tree(self.repo, commit)
-        if not paths:
-            self.entries = new_inst.entries
-        else:
-            nie = new_inst.entries
-            for path in paths:
-                path = self._to_relative_path(path)
-                try:
-                    key = entry_key(path, 0)
-                    self.entries[key] = nie[key]
-                except KeyError:
-                    # If key is not in theirs, it musn't be in ours.
-                    try:
-                        del self.entries[key]
-                    except KeyError:
-                        pass
-                    # END handle deletion keyerror
-                # END handle keyerror
-            # END for each path
-        # END handle paths
-        self.write()
-
-        if working_tree:
-            self.checkout(paths=paths, force=True)
-        # END handle working tree
-
-        if head:
-            self.repo.head.set_commit(self.repo.commit(commit), logmsg="%s: Updating HEAD" % commit)
-        # END handle head change
-
-        return self
-
-    # FIXME: This is documented to accept the same parameters as Diffable.diff, but this
-    # does not handle NULL_TREE for `other`. (The suppressed mypy error is about this.)
-    def diff(
-        self,
-        other: Union[  # type: ignore[override]
-            Literal[git_diff.DiffConstants.INDEX],
-            "Tree",
-            "Commit",
-            str,
-            None,
-        ] = git_diff.INDEX,
-        paths: Union[PathLike, List[PathLike], Tuple[PathLike, ...], None] = None,
-        create_patch: bool = False,
-        **kwargs: Any,
-    ) -> git_diff.DiffIndex:
-        """Diff this index against the working copy or a :class:`~git.objects.tree.Tree`
-        or :class:`~git.objects.commit.Commit` object.
-
-        For documentation of the parameters and return values, see
-        :meth:`Diffable.diff <git.diff.Diffable.diff>`.
-
-        :note:
-            Will only work with indices that represent the default git index as they
-            have not been initialized with a stream.
-        """
-        # Only run if we are the default repository index.
-        if self._file_path != self._index_path():
-            raise AssertionError("Cannot call %r on indices that do not represent the default git index" % self.diff())
-        # Index against index is always empty.
-        if other is self.INDEX:
-            return git_diff.DiffIndex()
-
-        # Index against anything but None is a reverse diff with the respective item.
-        # Handle existing -R flags properly.
-        # Transform strings to the object so that we can call diff on it.
-        if isinstance(other, str):
-            other = self.repo.rev_parse(other)
-        # END object conversion
-
-        if isinstance(other, Object):  # For Tree or Commit.
-            # Invert the existing R flag.
-            cur_val = kwargs.get("R", False)
-            kwargs["R"] = not cur_val
-            return other.diff(self.INDEX, paths, create_patch, **kwargs)
-        # END diff against other item handling
-
-        # If other is not None here, something is wrong.
-        if other is not None:
-            raise ValueError("other must be None, Diffable.INDEX, a Tree or Commit, was %r" % other)
-
-        # Diff against working copy - can be handled by superclass natively.
-        return super().diff(other, paths, create_patch, **kwargs)

ILYA/Lib/site-packages/git/index/fun.py

@@ -1,465 +0,0 @@
-# This module is part of GitPython and is released under the
-# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
-
-"""Standalone functions to accompany the index implementation and make it more
-versatile."""
-
-__all__ = [
-    "write_cache",
-    "read_cache",
-    "write_tree_from_cache",
-    "entry_key",
-    "stat_mode_to_index_mode",
-    "S_IFGITLINK",
-    "run_commit_hook",
-    "hook_path",
-]
-
-from io import BytesIO
-import os
-import os.path as osp
-from pathlib import Path
-from stat import S_IFDIR, S_IFLNK, S_IFMT, S_IFREG, S_ISDIR, S_ISLNK, S_IXUSR
-import subprocess
-import sys
-
-from gitdb.base import IStream
-from gitdb.typ import str_tree_type
-
-from git.cmd import handle_process_output, safer_popen
-from git.compat import defenc, force_bytes, force_text, safe_decode
-from git.exc import HookExecutionError, UnmergedEntriesError
-from git.objects.fun import (
-    traverse_tree_recursive,
-    traverse_trees_recursive,
-    tree_to_stream,
-)
-from git.util import IndexFileSHA1Writer, finalize_process
-
-from .typ import BaseIndexEntry, IndexEntry, CE_NAMEMASK, CE_STAGESHIFT
-from .util import pack, unpack
-
-# typing -----------------------------------------------------------------------------
-
-from typing import Dict, IO, List, Sequence, TYPE_CHECKING, Tuple, Type, Union, cast
-
-from git.types import PathLike
-
-if TYPE_CHECKING:
-    from git.db import GitCmdObjectDB
-    from git.objects.tree import TreeCacheTup
-
-    from .base import IndexFile
-
-# ------------------------------------------------------------------------------------
-
-S_IFGITLINK = S_IFLNK | S_IFDIR
-"""Flags for a submodule."""
-
-CE_NAMEMASK_INV = ~CE_NAMEMASK
-
-
-def hook_path(name: str, git_dir: PathLike) -> str:
-    """:return: path to the given named hook in the given git repository directory"""
-    return osp.join(git_dir, "hooks", name)
-
-
-def _has_file_extension(path: str) -> str:
-    return osp.splitext(path)[1]
-
-
-def run_commit_hook(name: str, index: "IndexFile", *args: str) -> None:
-    """Run the commit hook of the given name. Silently ignore hooks that do not exist.
-
-    :param name:
-        Name of hook, like ``pre-commit``.
-
-    :param index:
-        :class:`~git.index.base.IndexFile` instance.
-
-    :param args:
-        Arguments passed to hook file.
-
-    :raise git.exc.HookExecutionError:
-    """
-    hp = hook_path(name, index.repo.git_dir)
-    if not os.access(hp, os.X_OK):
-        return
-
-    env = os.environ.copy()
-    env["GIT_INDEX_FILE"] = safe_decode(str(index.path))
-    env["GIT_EDITOR"] = ":"
-    cmd = [hp]
-    try:
-        if sys.platform == "win32" and not _has_file_extension(hp):
-            # Windows only uses extensions to determine how to open files
-            # (doesn't understand shebangs). Try using bash to run the hook.
-            relative_hp = Path(hp).relative_to(index.repo.working_dir).as_posix()
-            cmd = ["bash.exe", relative_hp]
-
-        process = safer_popen(
-            cmd + list(args),
-            env=env,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            cwd=index.repo.working_dir,
-        )
-    except Exception as ex:
-        raise HookExecutionError(hp, ex) from ex
-    else:
-        stdout_list: List[str] = []
-        stderr_list: List[str] = []
-        handle_process_output(process, stdout_list.append, stderr_list.append, finalize_process)
-        stdout = "".join(stdout_list)
-        stderr = "".join(stderr_list)
-        if process.returncode != 0:
-            stdout = force_text(stdout, defenc)
-            stderr = force_text(stderr, defenc)
-            raise HookExecutionError(hp, process.returncode, stderr, stdout)
-    # END handle return code
-
-
-def stat_mode_to_index_mode(mode: int) -> int:
-    """Convert the given mode from a stat call to the corresponding index mode and
-    return it."""
-    if S_ISLNK(mode):  # symlinks
-        return S_IFLNK
-    if S_ISDIR(mode) or S_IFMT(mode) == S_IFGITLINK:  # submodules
-        return S_IFGITLINK
-    return S_IFREG | (mode & S_IXUSR and 0o755 or 0o644)  # blobs with or without executable bit
-
-
-def write_cache(
-    entries: Sequence[Union[BaseIndexEntry, "IndexEntry"]],
-    stream: IO[bytes],
-    extension_data: Union[None, bytes] = None,
-    ShaStreamCls: Type[IndexFileSHA1Writer] = IndexFileSHA1Writer,
-) -> None:
-    """Write the cache represented by entries to a stream.
-
-    :param entries:
-        **Sorted** list of entries.
-
-    :param stream:
-        Stream to wrap into the AdapterStreamCls - it is used for final output.
-
-    :param ShaStreamCls:
-        Type to use when writing to the stream. It produces a sha while writing to it,
-        before the data is passed on to the wrapped stream.
-
-    :param extension_data:
-        Any kind of data to write as a trailer, it must begin a 4 byte identifier,
-        followed by its size (4 bytes).
-    """
-    # Wrap the stream into a compatible writer.
-    stream_sha = ShaStreamCls(stream)
-
-    tell = stream_sha.tell
-    write = stream_sha.write
-
-    # Header
-    version = 2
-    write(b"DIRC")
-    write(pack(">LL", version, len(entries)))
-
-    # Body
-    for entry in entries:
-        beginoffset = tell()
-        write(entry.ctime_bytes)  # ctime
-        write(entry.mtime_bytes)  # mtime
-        path_str = str(entry.path)
-        path: bytes = force_bytes(path_str, encoding=defenc)
-        plen = len(path) & CE_NAMEMASK  # Path length
-        assert plen == len(path), "Path %s too long to fit into index" % entry.path
-        flags = plen | (entry.flags & CE_NAMEMASK_INV)  # Clear possible previous values.
-        write(
-            pack(
-                ">LLLLLL20sH",
-                entry.dev,
-                entry.inode,
-                entry.mode,
-                entry.uid,
-                entry.gid,
-                entry.size,
-                entry.binsha,
-                flags,
-            )
-        )
-        write(path)
-        real_size = (tell() - beginoffset + 8) & ~7
-        write(b"\0" * ((beginoffset + real_size) - tell()))
-    # END for each entry
-
-    # Write previously cached extensions data.
-    if extension_data is not None:
-        stream_sha.write(extension_data)
-
-    # Write the sha over the content.
-    stream_sha.write_sha()
-
-
-def read_header(stream: IO[bytes]) -> Tuple[int, int]:
-    """Return tuple(version_long, num_entries) from the given stream."""
-    type_id = stream.read(4)
-    if type_id != b"DIRC":
-        raise AssertionError("Invalid index file header: %r" % type_id)
-    unpacked = cast(Tuple[int, int], unpack(">LL", stream.read(4 * 2)))
-    version, num_entries = unpacked
-
-    # TODO: Handle version 3: extended data, see read-cache.c.
-    assert version in (1, 2)
-    return version, num_entries
-
-
-def entry_key(*entry: Union[BaseIndexEntry, PathLike, int]) -> Tuple[PathLike, int]:
-    """
-    :return:
-        Key suitable to be used for the
-        :attr:`index.entries <git.index.base.IndexFile.entries>` dictionary.
-
-    :param entry:
-        One instance of type BaseIndexEntry or the path and the stage.
-    """
-
-    # def is_entry_key_tup(entry_key: Tuple) -> TypeGuard[Tuple[PathLike, int]]:
-    #     return isinstance(entry_key, tuple) and len(entry_key) == 2
-
-    if len(entry) == 1:
-        entry_first = entry[0]
-        assert isinstance(entry_first, BaseIndexEntry)
-        return (entry_first.path, entry_first.stage)
-    else:
-        # assert is_entry_key_tup(entry)
-        entry = cast(Tuple[PathLike, int], entry)
-        return entry
-    # END handle entry
-
-
-def read_cache(
-    stream: IO[bytes],
-) -> Tuple[int, Dict[Tuple[PathLike, int], "IndexEntry"], bytes, bytes]:
-    """Read a cache file from the given stream.
-
-    :return:
-        tuple(version, entries_dict, extension_data, content_sha)
-
-        * *version* is the integer version number.
-        * *entries_dict* is a dictionary which maps IndexEntry instances to a path at a
-          stage.
-        * *extension_data* is ``""`` or 4 bytes of type + 4 bytes of size + size bytes.
-        * *content_sha* is a 20 byte sha on all cache file contents.
-    """
-    version, num_entries = read_header(stream)
-    count = 0
-    entries: Dict[Tuple[PathLike, int], "IndexEntry"] = {}
-
-    read = stream.read
-    tell = stream.tell
-    while count < num_entries:
-        beginoffset = tell()
-        ctime = unpack(">8s", read(8))[0]
-        mtime = unpack(">8s", read(8))[0]
-        (dev, ino, mode, uid, gid, size, sha, flags) = unpack(">LLLLLL20sH", read(20 + 4 * 6 + 2))
-        path_size = flags & CE_NAMEMASK
-        path = read(path_size).decode(defenc)
-
-        real_size = (tell() - beginoffset + 8) & ~7
-        read((beginoffset + real_size) - tell())
-        entry = IndexEntry((mode, sha, flags, path, ctime, mtime, dev, ino, uid, gid, size))
-        # entry_key would be the method to use, but we save the effort.
-        entries[(path, entry.stage)] = entry
-        count += 1
-    # END for each entry
-
-    # The footer contains extension data and a sha on the content so far.
-    # Keep the extension footer,and verify we have a sha in the end.
-    # Extension data format is:
-    #   4 bytes ID
-    #   4 bytes length of chunk
-    #   Repeated 0 - N times
-    extension_data = stream.read(~0)
-    assert len(extension_data) > 19, (
-        "Index Footer was not at least a sha on content as it was only %i bytes in size" % len(extension_data)
-    )
-
-    content_sha = extension_data[-20:]
-
-    # Truncate the sha in the end as we will dynamically create it anyway.
-    extension_data = extension_data[:-20]
-
-    return (version, entries, extension_data, content_sha)
-
-
-def write_tree_from_cache(
-    entries: List[IndexEntry], odb: "GitCmdObjectDB", sl: slice, si: int = 0
-) -> Tuple[bytes, List["TreeCacheTup"]]:
-    R"""Create a tree from the given sorted list of entries and put the respective
-    trees into the given object database.
-
-    :param entries:
-        **Sorted** list of :class:`~git.index.typ.IndexEntry`\s.
-
-    :param odb:
-        Object database to store the trees in.
-
-    :param si:
-        Start index at which we should start creating subtrees.
-
-    :param sl:
-        Slice indicating the range we should process on the entries list.
-
-    :return:
-        tuple(binsha, list(tree_entry, ...))
-
-        A tuple of a sha and a list of tree entries being a tuple of hexsha, mode, name.
-    """
-    tree_items: List["TreeCacheTup"] = []
-
-    ci = sl.start
-    end = sl.stop
-    while ci < end:
-        entry = entries[ci]
-        if entry.stage != 0:
-            raise UnmergedEntriesError(entry)
-        # END abort on unmerged
-        ci += 1
-        rbound = entry.path.find("/", si)
-        if rbound == -1:
-            # It's not a tree.
-            tree_items.append((entry.binsha, entry.mode, entry.path[si:]))
-        else:
-            # Find common base range.
-            base = entry.path[si:rbound]
-            xi = ci
-            while xi < end:
-                oentry = entries[xi]
-                orbound = oentry.path.find("/", si)
-                if orbound == -1 or oentry.path[si:orbound] != base:
-                    break
-                # END abort on base mismatch
-                xi += 1
-            # END find common base
-
-            # Enter recursion.
-            # ci - 1 as we want to count our current item as well.
-            sha, _tree_entry_list = write_tree_from_cache(entries, odb, slice(ci - 1, xi), rbound + 1)
-            tree_items.append((sha, S_IFDIR, base))
-
-            # Skip ahead.
-            ci = xi
-        # END handle bounds
-    # END for each entry
-
-    # Finally create the tree.
-    sio = BytesIO()
-    tree_to_stream(tree_items, sio.write)  # Writes to stream as bytes, but doesn't change tree_items.
-    sio.seek(0)
-
-    istream = odb.store(IStream(str_tree_type, len(sio.getvalue()), sio))
-    return (istream.binsha, tree_items)
-
-
-def _tree_entry_to_baseindexentry(tree_entry: "TreeCacheTup", stage: int) -> BaseIndexEntry:
-    return BaseIndexEntry((tree_entry[1], tree_entry[0], stage << CE_STAGESHIFT, tree_entry[2]))
-
-
-def aggressive_tree_merge(odb: "GitCmdObjectDB", tree_shas: Sequence[bytes]) -> List[BaseIndexEntry]:
-    R"""
-    :return:
-        List of :class:`~git.index.typ.BaseIndexEntry`\s representing the aggressive
-        merge of the given trees. All valid entries are on stage 0, whereas the
-        conflicting ones are left on stage 1, 2 or 3, whereas stage 1 corresponds to the
-        common ancestor tree, 2 to our tree and 3 to 'their' tree.
-
-    :param tree_shas:
-        1, 2 or 3 trees as identified by their binary 20 byte shas. If 1 or two, the
-        entries will effectively correspond to the last given tree. If 3 are given, a 3
-        way merge is performed.
-    """
-    out: List[BaseIndexEntry] = []
-
-    # One and two way is the same for us, as we don't have to handle an existing
-    # index, instrea
-    if len(tree_shas) in (1, 2):
-        for entry in traverse_tree_recursive(odb, tree_shas[-1], ""):
-            out.append(_tree_entry_to_baseindexentry(entry, 0))
-        # END for each entry
-        return out
-    # END handle single tree
-
-    if len(tree_shas) > 3:
-        raise ValueError("Cannot handle %i trees at once" % len(tree_shas))
-
-    # Three trees.
-    for base, ours, theirs in traverse_trees_recursive(odb, tree_shas, ""):
-        if base is not None:
-            # Base version exists.
-            if ours is not None:
-                # Ours exists.
-                if theirs is not None:
-                    # It exists in all branches. Ff it was changed in both
-                    # its a conflict. Otherwise, we take the changed version.
-                    # This should be the most common branch, so it comes first.
-                    if (base[0] != ours[0] and base[0] != theirs[0] and ours[0] != theirs[0]) or (
-                        base[1] != ours[1] and base[1] != theirs[1] and ours[1] != theirs[1]
-                    ):
-                        # Changed by both.
-                        out.append(_tree_entry_to_baseindexentry(base, 1))
-                        out.append(_tree_entry_to_baseindexentry(ours, 2))
-                        out.append(_tree_entry_to_baseindexentry(theirs, 3))
-                    elif base[0] != ours[0] or base[1] != ours[1]:
-                        # Only we changed it.
-                        out.append(_tree_entry_to_baseindexentry(ours, 0))
-                    else:
-                        # Either nobody changed it, or they did. In either
-                        # case, use theirs.
-                        out.append(_tree_entry_to_baseindexentry(theirs, 0))
-                    # END handle modification
-                else:
-                    if ours[0] != base[0] or ours[1] != base[1]:
-                        # They deleted it, we changed it, conflict.
-                        out.append(_tree_entry_to_baseindexentry(base, 1))
-                        out.append(_tree_entry_to_baseindexentry(ours, 2))
-                    # else:
-                    #   # We didn't change it, ignore.
-                    #   pass
-                    # END handle our change
-                # END handle theirs
-            else:
-                if theirs is None:
-                    # Deleted in both, its fine - it's out.
-                    pass
-                else:
-                    if theirs[0] != base[0] or theirs[1] != base[1]:
-                        # Deleted in ours, changed theirs, conflict.
-                        out.append(_tree_entry_to_baseindexentry(base, 1))
-                        out.append(_tree_entry_to_baseindexentry(theirs, 3))
-                    # END theirs changed
-                    # else:
-                    #   # Theirs didn't change.
-                    #   pass
-                # END handle theirs
-            # END handle ours
-        else:
-            # All three can't be None.
-            if ours is None:
-                # Added in their branch.
-                assert theirs is not None
-                out.append(_tree_entry_to_baseindexentry(theirs, 0))
-            elif theirs is None:
-                # Added in our branch.
-                out.append(_tree_entry_to_baseindexentry(ours, 0))
-            else:
-                # Both have it, except for the base, see whether it changed.
-                if ours[0] != theirs[0] or ours[1] != theirs[1]:
-                    out.append(_tree_entry_to_baseindexentry(ours, 2))
-                    out.append(_tree_entry_to_baseindexentry(theirs, 3))
-                else:
-                    # It was added the same in both.
-                    out.append(_tree_entry_to_baseindexentry(ours, 0))
-                # END handle two items
-            # END handle heads
-        # END handle base exists
-    # END for each entries tuple
-
-    return out

ILYA/Lib/site-packages/git/index/typ.py

@@ -1,202 +0,0 @@
-# This module is part of GitPython and is released under the
-# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
-
-"""Additional types used by the index."""
-
-__all__ = ["BlobFilter", "BaseIndexEntry", "IndexEntry", "StageType"]
-
-from binascii import b2a_hex
-from pathlib import Path
-
-from git.objects import Blob
-
-from .util import pack, unpack
-
-# typing ----------------------------------------------------------------------
-
-from typing import NamedTuple, Sequence, TYPE_CHECKING, Tuple, Union, cast
-
-from git.types import PathLike
-
-if TYPE_CHECKING:
-    from git.repo import Repo
-
-StageType = int
-
-# ---------------------------------------------------------------------------------
-
-# { Invariants
-CE_NAMEMASK = 0x0FFF
-CE_STAGEMASK = 0x3000
-CE_EXTENDED = 0x4000
-CE_VALID = 0x8000
-CE_STAGESHIFT = 12
-
-# } END invariants
-
-
-class BlobFilter:
-    """Predicate to be used by
-    :meth:`IndexFile.iter_blobs <git.index.base.IndexFile.iter_blobs>` allowing to
-    filter only return blobs which match the given list of directories or files.
-
-    The given paths are given relative to the repository.
-    """
-
-    __slots__ = ("paths",)
-
-    def __init__(self, paths: Sequence[PathLike]) -> None:
-        """
-        :param paths:
-            Tuple or list of paths which are either pointing to directories or to files
-            relative to the current repository.
-        """
-        self.paths = paths
-
-    def __call__(self, stage_blob: Tuple[StageType, Blob]) -> bool:
-        blob_pathlike: PathLike = stage_blob[1].path
-        blob_path: Path = blob_pathlike if isinstance(blob_pathlike, Path) else Path(blob_pathlike)
-        for pathlike in self.paths:
-            path: Path = pathlike if isinstance(pathlike, Path) else Path(pathlike)
-            # TODO: Change to use `PosixPath.is_relative_to` once Python 3.8 is no
-            # longer supported.
-            filter_parts = path.parts
-            blob_parts = blob_path.parts
-            if len(filter_parts) > len(blob_parts):
-                continue
-            if all(i == j for i, j in zip(filter_parts, blob_parts)):
-                return True
-        return False
-
-
-class BaseIndexEntryHelper(NamedTuple):
-    """Typed named tuple to provide named attribute access for :class:`BaseIndexEntry`.
-
-    This is needed to allow overriding ``__new__`` in child class to preserve backwards
-    compatibility.
-    """
-
-    mode: int
-    binsha: bytes
-    flags: int
-    path: PathLike
-    ctime_bytes: bytes = pack(">LL", 0, 0)
-    mtime_bytes: bytes = pack(">LL", 0, 0)
-    dev: int = 0
-    inode: int = 0
-    uid: int = 0
-    gid: int = 0
-    size: int = 0
-
-
-class BaseIndexEntry(BaseIndexEntryHelper):
-    R"""Small brother of an index entry which can be created to describe changes
-    done to the index in which case plenty of additional information is not required.
-
-    As the first 4 data members match exactly to the :class:`IndexEntry` type, methods
-    expecting a :class:`BaseIndexEntry` can also handle full :class:`IndexEntry`\s even
-    if they use numeric indices for performance reasons.
-    """
-
-    def __new__(
-        cls,
-        inp_tuple: Union[
-            Tuple[int, bytes, int, PathLike],
-            Tuple[int, bytes, int, PathLike, bytes, bytes, int, int, int, int, int],
-        ],
-    ) -> "BaseIndexEntry":
-        """Override ``__new__`` to allow construction from a tuple for backwards
-        compatibility."""
-        return super().__new__(cls, *inp_tuple)
-
-    def __str__(self) -> str:
-        return "%o %s %i\t%s" % (self.mode, self.hexsha, self.stage, self.path)
-
-    def __repr__(self) -> str:
-        return "(%o, %s, %i, %s)" % (self.mode, self.hexsha, self.stage, self.path)
-
-    @property
-    def hexsha(self) -> str:
-        """hex version of our sha"""
-        return b2a_hex(self.binsha).decode("ascii")
-
-    @property
-    def stage(self) -> int:
-        """Stage of the entry, either:
-
-            * 0 = default stage
-            * 1 = stage before a merge or common ancestor entry in case of a 3 way merge
-            * 2 = stage of entries from the 'left' side of the merge
-            * 3 = stage of entries from the 'right' side of the merge
-
-        :note:
-            For more information, see :manpage:`git-read-tree(1)`.
-        """
-        return (self.flags & CE_STAGEMASK) >> CE_STAGESHIFT
-
-    @classmethod
-    def from_blob(cls, blob: Blob, stage: int = 0) -> "BaseIndexEntry":
-        """:return: Fully equipped BaseIndexEntry at the given stage"""
-        return cls((blob.mode, blob.binsha, stage << CE_STAGESHIFT, blob.path))
-
-    def to_blob(self, repo: "Repo") -> Blob:
-        """:return: Blob using the information of this index entry"""
-        return Blob(repo, self.binsha, self.mode, self.path)
-
-
-class IndexEntry(BaseIndexEntry):
-    """Allows convenient access to index entry data as defined in
-    :class:`BaseIndexEntry` without completely unpacking it.
-
-    Attributes usually accessed often are cached in the tuple whereas others are
-    unpacked on demand.
-
-    See the properties for a mapping between names and tuple indices.
-    """
-
-    @property
-    def ctime(self) -> Tuple[int, int]:
-        """
-        :return:
-            Tuple(int_time_seconds_since_epoch, int_nano_seconds) of the
-            file's creation time
-        """
-        return cast(Tuple[int, int], unpack(">LL", self.ctime_bytes))
-
-    @property
-    def mtime(self) -> Tuple[int, int]:
-        """See :attr:`ctime` property, but returns modification time."""
-        return cast(Tuple[int, int], unpack(">LL", self.mtime_bytes))
-
-    @classmethod
-    def from_base(cls, base: "BaseIndexEntry") -> "IndexEntry":
-        """
-        :return:
-            Minimal entry as created from the given :class:`BaseIndexEntry` instance.
-            Missing values will be set to null-like values.
-
-        :param base:
-            Instance of type :class:`BaseIndexEntry`.
-        """
-        time = pack(">LL", 0, 0)
-        return IndexEntry((base.mode, base.binsha, base.flags, base.path, time, time, 0, 0, 0, 0, 0))
-
-    @classmethod
-    def from_blob(cls, blob: Blob, stage: int = 0) -> "IndexEntry":
-        """:return: Minimal entry resembling the given blob object"""
-        time = pack(">LL", 0, 0)
-        return IndexEntry(
-            (
-                blob.mode,
-                blob.binsha,
-                stage << CE_STAGESHIFT,
-                blob.path,
-                time,
-                time,
-                0,
-                0,
-                0,
-                0,
-                blob.size,
-            )
-        )

ILYA/Lib/site-packages/git/index/util.py

@@ -1,121 +0,0 @@
-# This module is part of GitPython and is released under the
-# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
-
-"""Index utilities."""
-
-__all__ = ["TemporaryFileSwap", "post_clear_cache", "default_index", "git_working_dir"]
-
-import contextlib
-from functools import wraps
-import os
-import os.path as osp
-import struct
-import tempfile
-from types import TracebackType
-
-# typing ----------------------------------------------------------------------
-
-from typing import Any, Callable, TYPE_CHECKING, Optional, Type
-
-from git.types import Literal, PathLike, _T
-
-if TYPE_CHECKING:
-    from git.index import IndexFile
-
-# ---------------------------------------------------------------------------------
-
-# { Aliases
-pack = struct.pack
-unpack = struct.unpack
-# } END aliases
-
-
-class TemporaryFileSwap:
-    """Utility class moving a file to a temporary location within the same directory and
-    moving it back on to where on object deletion."""
-
-    __slots__ = ("file_path", "tmp_file_path")
-
-    def __init__(self, file_path: PathLike) -> None:
-        self.file_path = file_path
-        dirname, basename = osp.split(file_path)
-        fd, self.tmp_file_path = tempfile.mkstemp(prefix=basename, dir=dirname)
-        os.close(fd)
-        with contextlib.suppress(OSError):  # It may be that the source does not exist.
-            os.replace(self.file_path, self.tmp_file_path)
-
-    def __enter__(self) -> "TemporaryFileSwap":
-        return self
-
-    def __exit__(
-        self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
-    ) -> Literal[False]:
-        if osp.isfile(self.tmp_file_path):
-            os.replace(self.tmp_file_path, self.file_path)
-        return False
-
-
-# { Decorators
-
-
-def post_clear_cache(func: Callable[..., _T]) -> Callable[..., _T]:
-    """Decorator for functions that alter the index using the git command.
-
-    When a git command alters the index, this invalidates our possibly existing entries
-    dictionary, which is why it must be deleted to allow it to be lazily reread later.
-    """
-
-    @wraps(func)
-    def post_clear_cache_if_not_raised(self: "IndexFile", *args: Any, **kwargs: Any) -> _T:
-        rval = func(self, *args, **kwargs)
-        self._delete_entries_cache()
-        return rval
-
-    # END wrapper method
-
-    return post_clear_cache_if_not_raised
-
-
-def default_index(func: Callable[..., _T]) -> Callable[..., _T]:
-    """Decorator ensuring the wrapped method may only run if we are the default
-    repository index.
-
-    This is as we rely on git commands that operate on that index only.
-    """
-
-    @wraps(func)
-    def check_default_index(self: "IndexFile", *args: Any, **kwargs: Any) -> _T:
-        if self._file_path != self._index_path():
-            raise AssertionError(
-                "Cannot call %r on indices that do not represent the default git index" % func.__name__
-            )
-        return func(self, *args, **kwargs)
-
-    # END wrapper method
-
-    return check_default_index
-
-
-def git_working_dir(func: Callable[..., _T]) -> Callable[..., _T]:
-    """Decorator which changes the current working dir to the one of the git
-    repository in order to ensure relative paths are handled correctly."""
-
-    @wraps(func)
-    def set_git_working_dir(self: "IndexFile", *args: Any, **kwargs: Any) -> _T:
-        cur_wd = os.getcwd()
-        os.chdir(str(self.repo.working_tree_dir))
-        try:
-            return func(self, *args, **kwargs)
-        finally:
-            os.chdir(cur_wd)
-        # END handle working dir
-
-    # END wrapper
-
-    return set_git_working_dir
-
-
-# } END decorators

ILYA/Lib/site-packages/git/objects/__init__.py

@@ -1,25 +0,0 @@
-# This module is part of GitPython and is released under the
-# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
-
-"""Import all submodules' main classes into the package space."""
-
-__all__ = [
-    "IndexObject",
-    "Object",
-    "Blob",
-    "Commit",
-    "Submodule",
-    "UpdateProgress",
-    "RootModule",
-    "RootUpdateProgress",
-    "TagObject",
-    "Tree",
-    "TreeModifier",
-]
-
-from .base import IndexObject, Object
-from .blob import Blob
-from .commit import Commit
-from .submodule import RootModule, RootUpdateProgress, Submodule, UpdateProgress
-from .tag import TagObject
-from .tree import Tree, TreeModifier

ILYA/Lib/site-packages/git/objects/base.py

@@ -1,301 +0,0 @@
-# Copyright (C) 2008, 2009 Michael Trier ([email protected]) and contributors
-#
-# This module is part of GitPython and is released under the
-# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
-
-__all__ = ["Object", "IndexObject"]
-
-import os.path as osp
-
-import gitdb.typ as dbtyp
-
-from git.exc import WorkTreeRepositoryUnsupported
-from git.util import LazyMixin, bin_to_hex, join_path_native, stream_copy
-
-from .util import get_object_type_by_name
-
-# typing ------------------------------------------------------------------
-
-from typing import Any, TYPE_CHECKING, Union
-
-from git.types import AnyGitObject, GitObjectTypeString, PathLike
-
-if TYPE_CHECKING:
-    from gitdb.base import OStream
-
-    from git.refs.reference import Reference
-    from git.repo import Repo
-
-    from .blob import Blob
-    from .submodule.base import Submodule
-    from .tree import Tree
-
-IndexObjUnion = Union["Tree", "Blob", "Submodule"]
-
-# --------------------------------------------------------------------------
-
-
-class Object(LazyMixin):
-    """Base class for classes representing git object types.
-
-    The following four leaf classes represent specific kinds of git objects:
-
-    * :class:`Blob <git.objects.blob.Blob>`
-    * :class:`Tree <git.objects.tree.Tree>`
-    * :class:`Commit <git.objects.commit.Commit>`
-    * :class:`TagObject <git.objects.tag.TagObject>`
-
-    See :manpage:`gitglossary(7)` on:
-
-    * "object": https://git-scm.com/docs/gitglossary#def_object
-    * "object type": https://git-scm.com/docs/gitglossary#def_object_type
-    * "blob": https://git-scm.com/docs/gitglossary#def_blob_object
-    * "tree object": https://git-scm.com/docs/gitglossary#def_tree_object
-    * "commit object": https://git-scm.com/docs/gitglossary#def_commit_object
-    * "tag object": https://git-scm.com/docs/gitglossary#def_tag_object
-
-    :note:
-        See the :class:`~git.types.AnyGitObject` union type of the four leaf subclasses
-        that represent actual git object types.
-
-    :note:
-        :class:`~git.objects.submodule.base.Submodule` is defined under the hierarchy
-        rooted at this :class:`Object` class, even though submodules are not really a
-        type of git object. (This also applies to its
-        :class:`~git.objects.submodule.root.RootModule` subclass.)
-
-    :note:
-        This :class:`Object` class should not be confused with :class:`object` (the root
-        of the class hierarchy in Python).
-    """
-
-    NULL_HEX_SHA = "0" * 40
-    NULL_BIN_SHA = b"\0" * 20
-
-    TYPES = (
-        dbtyp.str_blob_type,
-        dbtyp.str_tree_type,
-        dbtyp.str_commit_type,
-        dbtyp.str_tag_type,
-    )
-
-    __slots__ = ("repo", "binsha", "size")
-
-    type: Union[GitObjectTypeString, None] = None
-    """String identifying (a concrete :class:`Object` subtype for) a git object type.
-
-    The subtypes that this may name correspond to the kinds of git objects that exist,
-    i.e., the objects that may be present in a git repository.
-
-    :note:
-        Most subclasses represent specific types of git objects and override this class
-        attribute accordingly. This attribute is ``None`` in the :class:`Object` base
-        class, as well as the :class:`IndexObject` intermediate subclass, but never
-        ``None`` in concrete leaf subclasses representing specific git object types.
-
-    :note:
-        See also :class:`~git.types.GitObjectTypeString`.
-    """
-
-    def __init__(self, repo: "Repo", binsha: bytes) -> None:
-        """Initialize an object by identifying it by its binary sha.
-
-        All keyword arguments will be set on demand if ``None``.
-
-        :param repo:
-            Repository this object is located in.
-
-        :param binsha:
-            20 byte SHA1
-        """
-        super().__init__()
-        self.repo = repo
-        self.binsha = binsha
-        assert len(binsha) == 20, "Require 20 byte binary sha, got %r, len = %i" % (
-            binsha,
-            len(binsha),
-        )
-
-    @classmethod
-    def new(cls, repo: "Repo", id: Union[str, "Reference"]) -> AnyGitObject:
-        """
-        :return:
-            New :class:`Object` instance of a type appropriate to the object type behind
-            `id`. The id of the newly created object will be a binsha even though the
-            input id may have been a `~git.refs.reference.Reference` or rev-spec.
-
-        :param id:
-            :class:`~git.refs.reference.Reference`, rev-spec, or hexsha.
-
-        :note:
-            This cannot be a ``__new__`` method as it would always call :meth:`__init__`
-            with the input id which is not necessarily a binsha.
-        """
-        return repo.rev_parse(str(id))
-
-    @classmethod
-    def new_from_sha(cls, repo: "Repo", sha1: bytes) -> AnyGitObject:
-        """
-        :return:
-            New object instance of a type appropriate to represent the given binary sha1
-
-        :param sha1:
-            20 byte binary sha1.
-        """
-        if sha1 == cls.NULL_BIN_SHA:
-            # The NULL binsha is always the root commit.
-            return get_object_type_by_name(b"commit")(repo, sha1)
-        # END handle special case
-        oinfo = repo.odb.info(sha1)
-        inst = get_object_type_by_name(oinfo.type)(repo, oinfo.binsha)
-        inst.size = oinfo.size
-        return inst
-
-    def _set_cache_(self, attr: str) -> None:
-        """Retrieve object information."""
-        if attr == "size":
-            oinfo = self.repo.odb.info(self.binsha)
-            self.size = oinfo.size  # type: int
-        else:
-            super()._set_cache_(attr)
-
-    def __eq__(self, other: Any) -> bool:
-        """:return: ``True`` if the objects have the same SHA1"""
-        if not hasattr(other, "binsha"):
-            return False
-        return self.binsha == other.binsha
-
-    def __ne__(self, other: Any) -> bool:
-        """:return: ``True`` if the objects do not have the same SHA1"""
-        if not hasattr(other, "binsha"):
-            return True
-        return self.binsha != other.binsha
-
-    def __hash__(self) -> int:
-        """:return: Hash of our id allowing objects to be used in dicts and sets"""
-        return hash(self.binsha)
-
-    def __str__(self) -> str:
-        """:return: String of our SHA1 as understood by all git commands"""
-        return self.hexsha
-
-    def __repr__(self) -> str:
-        """:return: String with pythonic representation of our object"""
-        return '<git.%s "%s">' % (self.__class__.__name__, self.hexsha)
-
-    @property
-    def hexsha(self) -> str:
-        """:return: 40 byte hex version of our 20 byte binary sha"""
-        # b2a_hex produces bytes.
-        return bin_to_hex(self.binsha).decode("ascii")
-
-    @property
-    def data_stream(self) -> "OStream":
-        """
-        :return:
-            File-object compatible stream to the uncompressed raw data of the object
-
-        :note:
-            Returned streams must be read in order.
-        """
-        return self.repo.odb.stream(self.binsha)
-
-    def stream_data(self, ostream: "OStream") -> "Object":
-        """Write our data directly to the given output stream.
-
-        :param ostream:
-            File-object compatible stream object.
-
-        :return:
-            self
-        """
-        istream = self.repo.odb.stream(self.binsha)
-        stream_copy(istream, ostream)
-        return self
-
-
-class IndexObject(Object):
-    """Base for all objects that can be part of the index file.
-
-    The classes representing git object types that can be part of the index file are
-    :class:`~git.objects.tree.Tree and :class:`~git.objects.blob.Blob`. In addition,
-    :class:`~git.objects.submodule.base.Submodule`, which is not really a git object
-    type but can be part of an index file, is also a subclass.
-    """
-
-    __slots__ = ("path", "mode")
-
-    # For compatibility with iterable lists.
-    _id_attribute_ = "path"
-
-    def __init__(
-        self,
-        repo: "Repo",
-        binsha: bytes,
-        mode: Union[None, int] = None,
-        path: Union[None, PathLike] = None,
-    ) -> None:
-        """Initialize a newly instanced :class:`IndexObject`.
-
-        :param repo:
-            The :class:`~git.repo.base.Repo` we are located in.
-
-        :param binsha:
-            20 byte sha1.
-
-        :param mode:
-            The stat-compatible file mode as :class:`int`.
-            Use the :mod:`stat` module to evaluate the information.
-
-        :param path:
-            The path to the file in the file system, relative to the git repository
-            root, like ``file.ext`` or ``folder/other.ext``.
-
-        :note:
-            Path may not be set if the index object has been created directly, as it
-            cannot be retrieved without knowing the parent tree.
-        """
-        super().__init__(repo, binsha)
-        if mode is not None:
-            self.mode = mode
-        if path is not None:
-            self.path = path
-
-    def __hash__(self) -> int:
-        """
-        :return:
-            Hash of our path as index items are uniquely identifiable by path, not by
-            their data!
-        """
-        return hash(self.path)
-
-    def _set_cache_(self, attr: str) -> None:
-        if attr in IndexObject.__slots__:
-            # They cannot be retrieved later on (not without searching for them).
-            raise AttributeError(
-                "Attribute '%s' unset: path and mode attributes must have been set during %s object creation"
-                % (attr, type(self).__name__)
-            )
-        else:
-            super()._set_cache_(attr)
-        # END handle slot attribute
-
-    @property
-    def name(self) -> str:
-        """:return: Name portion of the path, effectively being the basename"""
-        return osp.basename(self.path)
-
-    @property
-    def abspath(self) -> PathLike:
-        R"""
-        :return:
-            Absolute path to this index object in the file system (as opposed to the
-            :attr:`path` field which is a path relative to the git repository).
-
-            The returned path will be native to the system and contains ``\`` on
-            Windows.
-        """
-        if self.repo.working_tree_dir is not None:
-            return join_path_native(self.repo.working_tree_dir, self.path)
-        else:
-            raise WorkTreeRepositoryUnsupported("working_tree_dir was None or empty")

ILYA/Lib/site-packages/git/objects/blob.py

@@ -1,48 +0,0 @@
-# Copyright (C) 2008, 2009 Michael Trier ([email protected]) and contributors
-#
-# This module is part of GitPython and is released under the
-# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
-
-__all__ = ["Blob"]
-
-from mimetypes import guess_type
-import sys
-
-if sys.version_info >= (3, 8):
-    from typing import Literal
-else:
-    from typing_extensions import Literal
-
-from . import base
-
-
-class Blob(base.IndexObject):
-    """A Blob encapsulates a git blob object.
-
-    See :manpage:`gitglossary(7)` on "blob":
-    https://git-scm.com/docs/gitglossary#def_blob_object
-    """
-
-    DEFAULT_MIME_TYPE = "text/plain"
-    type: Literal["blob"] = "blob"
-
-    # Valid blob modes
-    executable_mode = 0o100755
-    file_mode = 0o100644
-    link_mode = 0o120000
-
-    __slots__ = ()
-
-    @property
-    def mime_type(self) -> str:
-        """
-        :return:
-            String describing the mime type of this file (based on the filename)
-
-        :note:
-            Defaults to ``text/plain`` in case the actual file type is unknown.
-        """
-        guesses = None
-        if self.path:
-            guesses = guess_type(str(self.path))
-        return guesses and guesses[0] or self.DEFAULT_MIME_TYPE

ILYA/Lib/site-packages/git/objects/commit.py

@@ -1,899 +0,0 @@
-# Copyright (C) 2008, 2009 Michael Trier ([email protected]) and contributors
-#
-# This module is part of GitPython and is released under the
-# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
-
-__all__ = ["Commit"]
-
-from collections import defaultdict
-import datetime
-from io import BytesIO
-import logging
-import os
-import re
-from subprocess import Popen, PIPE
-import sys
-from time import altzone, daylight, localtime, time, timezone
-import warnings
-
-from gitdb import IStream
-
-from git.cmd import Git
-from git.diff import Diffable
-from git.util import Actor, Stats, finalize_process, hex_to_bin
-
-from . import base
-from .tree import Tree
-from .util import (
-    Serializable,
-    TraversableIterableObj,
-    altz_to_utctz_str,
-    from_timestamp,
-    parse_actor_and_date,
-    parse_date,
-)
-
-# typing ------------------------------------------------------------------
-
-from typing import (
-    Any,
-    Dict,
-    IO,
-    Iterator,
-    List,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-    Union,
-    cast,
-)
-
-if sys.version_info >= (3, 8):
-    from typing import Literal
-else:
-    from typing_extensions import Literal
-
-from git.types import PathLike
-
-if TYPE_CHECKING:
-    from git.refs import SymbolicReference
-    from git.repo import Repo
-
-# ------------------------------------------------------------------------
-
-_logger = logging.getLogger(__name__)
-
-
-class Commit(base.Object, TraversableIterableObj, Diffable, Serializable):
-    """Wraps a git commit object.
-
-    See :manpage:`gitglossary(7)` on "commit object":
-    https://git-scm.com/docs/gitglossary#def_commit_object
-
-    :note:
-        This class will act lazily on some of its attributes and will query the value on
-        demand only if it involves calling the git binary.
-    """
-
-    # ENVIRONMENT VARIABLES
-    # Read when creating new commits.
-    env_author_date = "GIT_AUTHOR_DATE"
-    env_committer_date = "GIT_COMMITTER_DATE"
-
-    # CONFIGURATION KEYS
-    conf_encoding = "i18n.commitencoding"
-
-    # INVARIANTS
-    default_encoding = "UTF-8"
-
-    type: Literal["commit"] = "commit"
-
-    __slots__ = (
-        "tree",
-        "author",
-        "authored_date",
-        "author_tz_offset",
-        "committer",
-        "committed_date",
-        "committer_tz_offset",
-        "message",
-        "parents",
-        "encoding",
-        "gpgsig",
-    )
-
-    _id_attribute_ = "hexsha"
-
-    parents: Sequence["Commit"]
-
-    def __init__(
-        self,
-        repo: "Repo",
-        binsha: bytes,
-        tree: Union[Tree, None] = None,
-        author: Union[Actor, None] = None,
-        authored_date: Union[int, None] = None,
-        author_tz_offset: Union[None, float] = None,
-        committer: Union[Actor, None] = None,
-        committed_date: Union[int, None] = None,
-        committer_tz_offset: Union[None, float] = None,
-        message: Union[str, bytes, None] = None,
-        parents: Union[Sequence["Commit"], None] = None,
-        encoding: Union[str, None] = None,
-        gpgsig: Union[str, None] = None,
-    ) -> None:
-        """Instantiate a new :class:`Commit`. All keyword arguments taking ``None`` as
-        default will be implicitly set on first query.
-
-        :param binsha:
-            20 byte sha1.
-
-        :param tree:
-            A :class:`~git.objects.tree.Tree` object.
-
-        :param author:
-            The author :class:`~git.util.Actor` object.
-
-        :param authored_date: int_seconds_since_epoch
-            The authored DateTime - use :func:`time.gmtime` to convert it into a
-            different format.
-
-        :param author_tz_offset: int_seconds_west_of_utc
-            The timezone that the `authored_date` is in.
-
-        :param committer:
-            The committer string, as an :class:`~git.util.Actor` object.
-
-        :param committed_date: int_seconds_since_epoch
-            The committed DateTime - use :func:`time.gmtime` to convert it into a
-            different format.
-
-        :param committer_tz_offset: int_seconds_west_of_utc
-            The timezone that the `committed_date` is in.
-
-        :param message: string
-            The commit message.
-
-        :param encoding: string
-            Encoding of the message, defaults to UTF-8.
-
-        :param parents:
-            List or tuple of :class:`Commit` objects which are our parent(s) in the
-            commit dependency graph.
-
-        :return:
-            :class:`Commit`
-
-        :note:
-            Timezone information is in the same format and in the same sign as what
-            :func:`time.altzone` returns. The sign is inverted compared to git's UTC
-            timezone.
-        """
-        super().__init__(repo, binsha)
-        self.binsha = binsha
-        if tree is not None:
-            assert isinstance(tree, Tree), "Tree needs to be a Tree instance, was %s" % type(tree)
-        if tree is not None:
-            self.tree = tree
-        if author is not None:
-            self.author = author
-        if authored_date is not None:
-            self.authored_date = authored_date
-        if author_tz_offset is not None:
-            self.author_tz_offset = author_tz_offset
-        if committer is not None:
-            self.committer = committer
-        if committed_date is not None:
-            self.committed_date = committed_date
-        if committer_tz_offset is not None:
-            self.committer_tz_offset = committer_tz_offset
-        if message is not None:
-            self.message = message
-        if parents is not None:
-            self.parents = parents
-        if encoding is not None:
-            self.encoding = encoding
-        if gpgsig is not None:
-            self.gpgsig = gpgsig
-
-    @classmethod
-    def _get_intermediate_items(cls, commit: "Commit") -> Tuple["Commit", ...]:
-        return tuple(commit.parents)
-
-    @classmethod
-    def _calculate_sha_(cls, repo: "Repo", commit: "Commit") -> bytes:
-        """Calculate the sha of a commit.
-
-        :param repo:
-            :class:`~git.repo.base.Repo` object the commit should be part of.
-
-        :param commit:
-            :class:`Commit` object for which to generate the sha.
-        """
-
-        stream = BytesIO()
-        commit._serialize(stream)
-        streamlen = stream.tell()
-        stream.seek(0)
-
-        istream = repo.odb.store(IStream(cls.type, streamlen, stream))
-        return istream.binsha
-
-    def replace(self, **kwargs: Any) -> "Commit":
-        """Create new commit object from an existing commit object.
-
-        Any values provided as keyword arguments will replace the corresponding
-        attribute in the new object.
-        """
-
-        attrs = {k: getattr(self, k) for k in self.__slots__}
-
-        for attrname in kwargs:
-            if attrname not in self.__slots__:
-                raise ValueError("invalid attribute name")
-
-        attrs.update(kwargs)
-        new_commit = self.__class__(self.repo, self.NULL_BIN_SHA, **attrs)
-        new_commit.binsha = self._calculate_sha_(self.repo, new_commit)
-
-        return new_commit
-
-    def _set_cache_(self, attr: str) -> None:
-        if attr in Commit.__slots__:
-            # Read the data in a chunk, its faster - then provide a file wrapper.
-            _binsha, _typename, self.size, stream = self.repo.odb.stream(self.binsha)
-            self._deserialize(BytesIO(stream.read()))
-        else:
-            super()._set_cache_(attr)
-        # END handle attrs
-
-    @property
-    def authored_datetime(self) -> datetime.datetime:
-        return from_timestamp(self.authored_date, self.author_tz_offset)
-
-    @property
-    def committed_datetime(self) -> datetime.datetime:
-        return from_timestamp(self.committed_date, self.committer_tz_offset)
-
-    @property
-    def summary(self) -> Union[str, bytes]:
-        """:return: First line of the commit message"""
-        if isinstance(self.message, str):
-            return self.message.split("\n", 1)[0]
-        else:
-            return self.message.split(b"\n", 1)[0]
-
-    def count(self, paths: Union[PathLike, Sequence[PathLike]] = "", **kwargs: Any) -> int:
-        """Count the number of commits reachable from this commit.
-
-        :param paths:
-            An optional path or a list of paths restricting the return value to commits
-            actually containing the paths.
-
-        :param kwargs:
-            Additional options to be passed to :manpage:`git-rev-list(1)`. They must not
-            alter the output style of the command, or parsing will yield incorrect
-            results.
-
-        :return:
-            An int defining the number of reachable commits
-        """
-        # Yes, it makes a difference whether empty paths are given or not in our case as
-        # the empty paths version will ignore merge commits for some reason.
-        if paths:
-            return len(self.repo.git.rev_list(self.hexsha, "--", paths, **kwargs).splitlines())
-        return len(self.repo.git.rev_list(self.hexsha, **kwargs).splitlines())
-
-    @property
-    def name_rev(self) -> str:
-        """
-        :return:
-            String describing the commits hex sha based on the closest
-            `~git.refs.reference.Reference`.
-
-        :note:
-            Mostly useful for UI purposes.
-        """
-        return self.repo.git.name_rev(self)
-
-    @classmethod
-    def iter_items(
-        cls,
-        repo: "Repo",
-        rev: Union[str, "Commit", "SymbolicReference"],
-        paths: Union[PathLike, Sequence[PathLike]] = "",
-        **kwargs: Any,
-    ) -> Iterator["Commit"]:
-        R"""Find all commits matching the given criteria.
-
-        :param repo:
-            The :class:`~git.repo.base.Repo`.
-
-        :param rev:
-            Revision specifier. See :manpage:`git-rev-parse(1)` for viable options.
-
-        :param paths:
-            An optional path or list of paths. If set only :class:`Commit`\s that
-            include the path or paths will be considered.
-
-        :param kwargs:
-            Optional keyword arguments to :manpage:`git-rev-list(1)` where:
-
-            * ``max_count`` is the maximum number of commits to fetch.
-            * ``skip`` is the number of commits to skip.
-            * ``since`` selects all commits since some date, e.g. ``"1970-01-01"``.
-
-        :return:
-            Iterator yielding :class:`Commit` items.
-        """
-        if "pretty" in kwargs:
-            raise ValueError("--pretty cannot be used as parsing expects single sha's only")
-        # END handle pretty
-
-        # Use -- in all cases, to prevent possibility of ambiguous arguments.
-        # See https://github.com/gitpython-developers/GitPython/issues/264.
-
-        args_list: List[PathLike] = ["--"]
-
-        if paths:
-            paths_tup: Tuple[PathLike, ...]
-            if isinstance(paths, (str, os.PathLike)):
-                paths_tup = (paths,)
-            else:
-                paths_tup = tuple(paths)
-
-            args_list.extend(paths_tup)
-        # END if paths
-
-        proc = repo.git.rev_list(rev, args_list, as_process=True, **kwargs)
-        return cls._iter_from_process_or_stream(repo, proc)
-
-    def iter_parents(self, paths: Union[PathLike, Sequence[PathLike]] = "", **kwargs: Any) -> Iterator["Commit"]:
-        R"""Iterate _all_ parents of this commit.
-
-        :param paths:
-            Optional path or list of paths limiting the :class:`Commit`\s to those that
-            contain at least one of the paths.
-
-        :param kwargs:
-            All arguments allowed by :manpage:`git-rev-list(1)`.
-
-        :return:
-            Iterator yielding :class:`Commit` objects which are parents of ``self``
-        """
-        # skip ourselves
-        skip = kwargs.get("skip", 1)
-        if skip == 0:  # skip ourselves
-            skip = 1
-        kwargs["skip"] = skip
-
-        return self.iter_items(self.repo, self, paths, **kwargs)
-
-    @property
-    def stats(self) -> Stats:
-        """Create a git stat from changes between this commit and its first parent
-        or from all changes done if this is the very first commit.
-
-        :return:
-            :class:`Stats`
-        """
-        if not self.parents:
-            text = self.repo.git.diff_tree(self.hexsha, "--", numstat=True, no_renames=True, root=True)
-            text2 = ""
-            for line in text.splitlines()[1:]:
-                (insertions, deletions, filename) = line.split("\t")
-                text2 += "%s\t%s\t%s\n" % (insertions, deletions, filename)
-            text = text2
-        else:
-            text = self.repo.git.diff(self.parents[0].hexsha, self.hexsha, "--", numstat=True, no_renames=True)
-        return Stats._list_from_string(self.repo, text)
-
-    @property
-    def trailers(self) -> Dict[str, str]:
-        """Deprecated. Get the trailers of the message as a dictionary.
-
-        :note:
-            This property is deprecated, please use either :attr:`trailers_list` or
-            :attr:`trailers_dict`.
-
-        :return:
-            Dictionary containing whitespace stripped trailer information.
-            Only contains the latest instance of each trailer key.
-        """
-        warnings.warn(
-            "Commit.trailers is deprecated, use Commit.trailers_list or Commit.trailers_dict instead",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        return {k: v[0] for k, v in self.trailers_dict.items()}
-
-    @property
-    def trailers_list(self) -> List[Tuple[str, str]]:
-        """Get the trailers of the message as a list.
-
-        Git messages can contain trailer information that are similar to :rfc:`822`
-        e-mail headers. See :manpage:`git-interpret-trailers(1)`.
-
-        This function calls ``git interpret-trailers --parse`` onto the message to
-        extract the trailer information, returns the raw trailer data as a list.
-
-        Valid message with trailer::
-
-            Subject line
-
-            some body information
-
-            another information
-
-            key1: value1.1
-            key1: value1.2
-            key2 :    value 2 with inner spaces
-
-        Returned list will look like this::
-
-            [
-                ("key1", "value1.1"),
-                ("key1", "value1.2"),
-                ("key2", "value 2 with inner spaces"),
-            ]
-
-        :return:
-            List containing key-value tuples of whitespace stripped trailer information.
-        """
-        cmd = ["git", "interpret-trailers", "--parse"]
-        proc: Git.AutoInterrupt = self.repo.git.execute(  # type: ignore[call-overload]
-            cmd,
-            as_process=True,
-            istream=PIPE,
-        )
-        trailer: str = proc.communicate(str(self.message).encode())[0].decode("utf8")
-        trailer = trailer.strip()
-
-        if not trailer:
-            return []
-
-        trailer_list = []
-        for t in trailer.split("\n"):
-            key, val = t.split(":", 1)
-            trailer_list.append((key.strip(), val.strip()))
-
-        return trailer_list
-
-    @property
-    def trailers_dict(self) -> Dict[str, List[str]]:
-        """Get the trailers of the message as a dictionary.
-
-        Git messages can contain trailer information that are similar to :rfc:`822`
-        e-mail headers. See :manpage:`git-interpret-trailers(1)`.
-
-        This function calls ``git interpret-trailers --parse`` onto the message to
-        extract the trailer information. The key value pairs are stripped of leading and
-        trailing whitespaces before they get saved into a dictionary.
-
-        Valid message with trailer::
-
-            Subject line
-
-            some body information
-
-            another information
-
-            key1: value1.1
-            key1: value1.2
-            key2 :    value 2 with inner spaces
-
-        Returned dictionary will look like this::
-
-            {
-                "key1": ["value1.1", "value1.2"],
-                "key2": ["value 2 with inner spaces"],
-            }
-
-
-        :return:
-            Dictionary containing whitespace stripped trailer information, mapping
-            trailer keys to a list of their corresponding values.
-        """
-        d = defaultdict(list)
-        for key, val in self.trailers_list:
-            d[key].append(val)
-        return dict(d)
-
-    @classmethod
-    def _iter_from_process_or_stream(cls, repo: "Repo", proc_or_stream: Union[Popen, IO]) -> Iterator["Commit"]:
-        """Parse out commit information into a list of :class:`Commit` objects.
-
-        We expect one line per commit, and parse the actual commit information directly
-        from our lighting fast object database.
-
-        :param proc:
-            :manpage:`git-rev-list(1)` process instance - one sha per line.
-
-        :return:
-            Iterator supplying :class:`Commit` objects
-        """
-
-        # def is_proc(inp) -> TypeGuard[Popen]:
-        #     return hasattr(proc_or_stream, 'wait') and not hasattr(proc_or_stream, 'readline')
-
-        # def is_stream(inp) -> TypeGuard[IO]:
-        #     return hasattr(proc_or_stream, 'readline')
-
-        if hasattr(proc_or_stream, "wait"):
-            proc_or_stream = cast(Popen, proc_or_stream)
-            if proc_or_stream.stdout is not None:
-                stream = proc_or_stream.stdout
-        elif hasattr(proc_or_stream, "readline"):
-            proc_or_stream = cast(IO, proc_or_stream)  # type: ignore[redundant-cast]
-            stream = proc_or_stream
-
-        readline = stream.readline
-        while True:
-            line = readline()
-            if not line:
-                break
-            hexsha = line.strip()
-            if len(hexsha) > 40:
-                # Split additional information, as returned by bisect for instance.
-                hexsha, _ = line.split(None, 1)
-            # END handle extra info
-
-            assert len(hexsha) == 40, "Invalid line: %s" % hexsha
-            yield cls(repo, hex_to_bin(hexsha))
-        # END for each line in stream
-
-        # TODO: Review this - it seems process handling got a bit out of control due to
-        # many developers trying to fix the open file handles issue.
-        if hasattr(proc_or_stream, "wait"):
-            proc_or_stream = cast(Popen, proc_or_stream)
-            finalize_process(proc_or_stream)
-
-    @classmethod
-    def create_from_tree(
-        cls,
-        repo: "Repo",
-        tree: Union[Tree, str],
-        message: str,
-        parent_commits: Union[None, List["Commit"]] = None,
-        head: bool = False,
-        author: Union[None, Actor] = None,
-        committer: Union[None, Actor] = None,
-        author_date: Union[None, str, datetime.datetime] = None,
-        commit_date: Union[None, str, datetime.datetime] = None,
-    ) -> "Commit":
-        """Commit the given tree, creating a :class:`Commit` object.
-
-        :param repo:
-            :class:`~git.repo.base.Repo` object the commit should be part of.
-
-        :param tree:
-            :class:`~git.objects.tree.Tree` object or hex or bin sha.
-            The tree of the new commit.
-
-        :param message:
-            Commit message. It may be an empty string if no message is provided. It will
-            be converted to a string, in any case.
-
-        :param parent_commits:
-            Optional :class:`Commit` objects to use as parents for the new commit. If
-            empty list, the commit will have no parents at all and become a root commit.
-            If ``None``, the current head commit will be the parent of the new commit
-            object.
-
-        :param head:
-            If ``True``, the HEAD will be advanced to the new commit automatically.
-            Otherwise the HEAD will remain pointing on the previous commit. This could
-            lead to undesired results when diffing files.
-
-        :param author:
-            The name of the author, optional.
-            If unset, the repository configuration is used to obtain this value.
-
-        :param committer:
-            The name of the committer, optional.
-            If unset, the repository configuration is used to obtain this value.
-
-        :param author_date:
-            The timestamp for the author field.
-
-        :param commit_date:
-            The timestamp for the committer field.
-
-        :return:
-            :class:`Commit` object representing the new commit.
-
-        :note:
-            Additional information about the committer and author are taken from the
-            environment or from the git configuration. See :manpage:`git-commit-tree(1)`
-            for more information.
-        """
-        if parent_commits is None:
-            try:
-                parent_commits = [repo.head.commit]
-            except ValueError:
-                # Empty repositories have no head commit.
-                parent_commits = []
-            # END handle parent commits
-        else:
-            for p in parent_commits:
-                if not isinstance(p, cls):
-                    raise ValueError(f"Parent commit '{p!r}' must be of type {cls}")
-            # END check parent commit types
-        # END if parent commits are unset
-
-        # Retrieve all additional information, create a commit object, and serialize it.
-        # Generally:
-        # * Environment variables override configuration values.
-        # * Sensible defaults are set according to the git documentation.
-
-        # COMMITTER AND AUTHOR INFO
-        cr = repo.config_reader()
-        env = os.environ
-
-        committer = committer or Actor.committer(cr)
-        author = author or Actor.author(cr)
-
-        # PARSE THE DATES
-        unix_time = int(time())
-        is_dst = daylight and localtime().tm_isdst > 0
-        offset = altzone if is_dst else timezone
-
-        author_date_str = env.get(cls.env_author_date, "")
-        if author_date:
-            author_time, author_offset = parse_date(author_date)
-        elif author_date_str:
-            author_time, author_offset = parse_date(author_date_str)
-        else:
-            author_time, author_offset = unix_time, offset
-        # END set author time
-
-        committer_date_str = env.get(cls.env_committer_date, "")
-        if commit_date:
-            committer_time, committer_offset = parse_date(commit_date)
-        elif committer_date_str:
-            committer_time, committer_offset = parse_date(committer_date_str)
-        else:
-            committer_time, committer_offset = unix_time, offset
-        # END set committer time
-
-        # Assume UTF-8 encoding.
-        enc_section, enc_option = cls.conf_encoding.split(".")
-        conf_encoding = cr.get_value(enc_section, enc_option, cls.default_encoding)
-        if not isinstance(conf_encoding, str):
-            raise TypeError("conf_encoding could not be coerced to str")
-
-        # If the tree is no object, make sure we create one - otherwise the created
-        # commit object is invalid.
-        if isinstance(tree, str):
-            tree = repo.tree(tree)
-        # END tree conversion
-
-        # CREATE NEW COMMIT
-        new_commit = cls(
-            repo,
-            cls.NULL_BIN_SHA,
-            tree,
-            author,
-            author_time,
-            author_offset,
-            committer,
-            committer_time,
-            committer_offset,
-            message,
-            parent_commits,
-            conf_encoding,
-        )
-
-        new_commit.binsha = cls._calculate_sha_(repo, new_commit)
-
-        if head:
-            # Need late import here, importing git at the very beginning throws as
-            # well...
-            import git.refs
-
-            try:
-                repo.head.set_commit(new_commit, logmsg=message)
-            except ValueError:
-                # head is not yet set to the ref our HEAD points to.
-                # Happens on first commit.
-                master = git.refs.Head.create(
-                    repo,
-                    repo.head.ref,
-                    new_commit,
-                    logmsg="commit (initial): %s" % message,
-                )
-                repo.head.set_reference(master, logmsg="commit: Switching to %s" % master)
-            # END handle empty repositories
-        # END advance head handling
-
-        return new_commit
-
-    # { Serializable Implementation
-
-    def _serialize(self, stream: BytesIO) -> "Commit":
-        write = stream.write
-        write(("tree %s\n" % self.tree).encode("ascii"))
-        for p in self.parents:
-            write(("parent %s\n" % p).encode("ascii"))
-
-        a = self.author
-        aname = a.name
-        c = self.committer
-        fmt = "%s %s <%s> %s %s\n"
-        write(
-            (
-                fmt
-                % (
-                    "author",
-                    aname,
-                    a.email,
-                    self.authored_date,
-                    altz_to_utctz_str(self.author_tz_offset),
-                )
-            ).encode(self.encoding)
-        )
-
-        # Encode committer.
-        aname = c.name
-        write(
-            (
-                fmt
-                % (
-                    "committer",
-                    aname,
-                    c.email,
-                    self.committed_date,
-                    altz_to_utctz_str(self.committer_tz_offset),
-                )
-            ).encode(self.encoding)
-        )
-
-        if self.encoding != self.default_encoding:
-            write(("encoding %s\n" % self.encoding).encode("ascii"))
-
-        try:
-            if self.__getattribute__("gpgsig"):
-                write(b"gpgsig")
-                for sigline in self.gpgsig.rstrip("\n").split("\n"):
-                    write((" " + sigline + "\n").encode("ascii"))
-        except AttributeError:
-            pass
-
-        write(b"\n")
-
-        # Write plain bytes, be sure its encoded according to our encoding.
-        if isinstance(self.message, str):
-            write(self.message.encode(self.encoding))
-        else:
-            write(self.message)
-        # END handle encoding
-        return self
-
-    def _deserialize(self, stream: BytesIO) -> "Commit":
-        readline = stream.readline
-        self.tree = Tree(self.repo, hex_to_bin(readline().split()[1]), Tree.tree_id << 12, "")
-
-        self.parents = []
-        next_line = None
-        while True:
-            parent_line = readline()
-            if not parent_line.startswith(b"parent"):
-                next_line = parent_line
-                break
-            # END abort reading parents
-            self.parents.append(type(self)(self.repo, hex_to_bin(parent_line.split()[-1].decode("ascii"))))
-        # END for each parent line
-        self.parents = tuple(self.parents)
-
-        # We don't know actual author encoding before we have parsed it, so keep the
-        # lines around.
-        author_line = next_line
-        committer_line = readline()
-
-        # We might run into one or more mergetag blocks, skip those for now.
-        next_line = readline()
-        while next_line.startswith(b"mergetag "):
-            next_line = readline()
-            while next_line.startswith(b" "):
-                next_line = readline()
-        # END skip mergetags
-
-        # Now we can have the encoding line, or an empty line followed by the optional
-        # message.
-        self.encoding = self.default_encoding
-        self.gpgsig = ""
-
-        # Read headers.
-        enc = next_line
-        buf = enc.strip()
-        while buf:
-            if buf[0:10] == b"encoding ":
-                self.encoding = buf[buf.find(b" ") + 1 :].decode(self.encoding, "ignore")
-            elif buf[0:7] == b"gpgsig ":
-                sig = buf[buf.find(b" ") + 1 :] + b"\n"
-                is_next_header = False
-                while True:
-                    sigbuf = readline()
-                    if not sigbuf:
-                        break
-                    if sigbuf[0:1] != b" ":
-                        buf = sigbuf.strip()
-                        is_next_header = True
-                        break
-                    sig += sigbuf[1:]
-                # END read all signature
-                self.gpgsig = sig.rstrip(b"\n").decode(self.encoding, "ignore")
-                if is_next_header:
-                    continue
-            buf = readline().strip()
-
-        # Decode the author's name.
-        try:
-            (
-                self.author,
-                self.authored_date,
-                self.author_tz_offset,
-            ) = parse_actor_and_date(author_line.decode(self.encoding, "replace"))
-        except UnicodeDecodeError:
-            _logger.error(
-                "Failed to decode author line '%s' using encoding %s",
-                author_line,
-                self.encoding,
-                exc_info=True,
-            )
-
-        try:
-            (
-                self.committer,
-                self.committed_date,
-                self.committer_tz_offset,
-            ) = parse_actor_and_date(committer_line.decode(self.encoding, "replace"))
-        except UnicodeDecodeError:
-            _logger.error(
-                "Failed to decode committer line '%s' using encoding %s",
-                committer_line,
-                self.encoding,
-                exc_info=True,
-            )
-        # END handle author's encoding
-
-        # A stream from our data simply gives us the plain message.
-        # The end of our message stream is marked with a newline that we strip.
-        self.message = stream.read()
-        try:
-            self.message = self.message.decode(self.encoding, "replace")
-        except UnicodeDecodeError:
-            _logger.error(
-                "Failed to decode message '%s' using encoding %s",
-                self.message,
-                self.encoding,
-                exc_info=True,
-            )
-        # END exception handling
-
-        return self
-
-    # } END serializable implementation
-
-    @property
-    def co_authors(self) -> List[Actor]:
-        """Search the commit message for any co-authors of this commit.
-
-        Details on co-authors:
-        https://github.blog/2018-01-29-commit-together-with-co-authors/
-
-        :return:
-            List of co-authors for this commit (as :class:`~git.util.Actor` objects).
-        """
-        co_authors = []
-
-        if self.message:
-            results = re.findall(
-                r"^Co-authored-by: (.*) <(.*?)>$",
-                self.message,
-                re.MULTILINE,
-            )
-            for author in results:
-                co_authors.append(Actor(*author))
-
-        return co_authors