pax_global_header00006660000000000000000000000064145032420450014511gustar00rootroot0000000000000052 comment=b27a89f683cda85ebd78243c055e876282df89ee GitPython-3.1.37/000077500000000000000000000000001450324204500135315ustar00rootroot00000000000000GitPython-3.1.37/.flake8000066400000000000000000000021231450324204500147020ustar00rootroot00000000000000[flake8] show-source = True count= True statistics = True # E265 = comment blocks like @{ section, which it can't handle # E266 = too many leading '#' for block comment # E731 = do not assign a lambda expression, use a def # W293 = Blank line contains whitespace # W504 = Line break after operator # E704 = multiple statements in one line - used for @override # TC002 = move third party import to TYPE_CHECKING # ANN = flake8-annotations # TC, TC2 = flake8-type-checking # D = flake8-docstrings # select = C,E,F,W ANN, TC, TC2 # to enable code. Disabled if not listed, including builtin codes enable-extensions = TC, TC2 # only needed for extensions not enabled by default ignore = E265,E266,E731,E704, W293, W504, ANN0 ANN1 ANN2, TC002, TC0, TC1, TC2 # B, A, D, RST, RST3 exclude = .tox,.venv,build,dist,doc,git/ext/ rst-roles = # for flake8-RST-docstrings attr,class,func,meth,mod,obj,ref,term,var # used by sphinx min-python-version = 3.7.0 # for `black` compatibility max-line-length = 120 extend-ignore = E203,W503 GitPython-3.1.37/.gitattributes000066400000000000000000000000641450324204500164240ustar00rootroot00000000000000test/fixtures/* eol=lf *.sh eol=lf /Makefile eol=lf GitPython-3.1.37/.github/000077500000000000000000000000001450324204500150715ustar00rootroot00000000000000GitPython-3.1.37/.github/FUNDING.yml000066400000000000000000000000161450324204500167030ustar00rootroot00000000000000github: byron GitPython-3.1.37/.github/dependabot.yml000066400000000000000000000001601450324204500177160ustar00rootroot00000000000000version: 2 updates: - package-ecosystem: "github-actions" directory: "/" schedule: interval: "weekly" GitPython-3.1.37/.github/workflows/000077500000000000000000000000001450324204500171265ustar00rootroot00000000000000GitPython-3.1.37/.github/workflows/cygwin-test.yml000066400000000000000000000032211450324204500221240ustar00rootroot00000000000000name: test-cygwin on: [push, pull_request, workflow_dispatch] jobs: build: runs-on: windows-latest strategy: fail-fast: false env: CHERE_INVOKING: 1 SHELLOPTS: igncr TMP: "/tmp" TEMP: "/tmp" defaults: run: shell: bash.exe --noprofile --norc -exo pipefail -o igncr "{0}" steps: - name: Force LF line endings run: git config --global core.autocrlf input - uses: actions/checkout@v4 with: fetch-depth: 0 submodules: recursive - uses: cygwin/cygwin-install-action@v4 with: packages: python39 python39-pip python39-virtualenv git - name: Show python and git versions run: | /usr/bin/python --version /usr/bin/git version - name: Tell git to trust this repo run: | /usr/bin/git config --global --add safe.directory "$(pwd)" - name: Prepare this repo for tests run: | TRAVIS=yes ./init-tests-after-clone.sh - name: Further prepare git configuration for tests run: | /usr/bin/git config --global user.email "travis@ci.com" /usr/bin/git config --global user.name "Travis Runner" # If we rewrite the user's config by accident, we will mess it up # and cause subsequent tests to fail cat test/fixtures/.gitconfig >> ~/.gitconfig - name: Update PyPA packages run: | /usr/bin/python -m pip install --upgrade pip setuptools wheel - name: Install project and test dependencies run: | /usr/bin/python -m pip install ".[test]" - name: Test with pytest run: | set +x /usr/bin/python -m pytest GitPython-3.1.37/.github/workflows/lint.yml000066400000000000000000000004131450324204500206150ustar00rootroot00000000000000name: Lint on: [push, pull_request, workflow_dispatch] jobs: lint: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - uses: actions/setup-python@v4 with: python-version: "3.x" - uses: pre-commit/action@v3.0.0 GitPython-3.1.37/.github/workflows/pythonpackage.yml000066400000000000000000000046321450324204500225130ustar00rootroot00000000000000# This workflow will install Python dependencies, run tests and lint with a variety of Python versions # For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions name: Python package on: [push, pull_request, workflow_dispatch] permissions: contents: read jobs: build: runs-on: ubuntu-latest strategy: fail-fast: false matrix: python-version: ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12"] include: - experimental: false - python-version: "3.12" experimental: true defaults: run: shell: /bin/bash --noprofile --norc -exo pipefail {0} steps: - uses: actions/checkout@v4 with: fetch-depth: 0 submodules: recursive - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v4 with: python-version: ${{ matrix.python-version }} allow-prereleases: ${{ matrix.experimental }} - name: Show python and git versions run: | python --version git version - name: Prepare this repo for tests run: | TRAVIS=yes ./init-tests-after-clone.sh - name: Prepare git configuration for tests run: | git config --global user.email "travis@ci.com" git config --global user.name "Travis Runner" # If we rewrite the user's config by accident, we will mess it up # and cause subsequent tests to fail cat test/fixtures/.gitconfig >> ~/.gitconfig - name: Update PyPA packages run: | python -m pip install --upgrade pip if pip freeze --all | grep --quiet '^setuptools=='; then # Python prior to 3.12 ships setuptools. Upgrade it if present. python -m pip install --upgrade setuptools fi python -m pip install --upgrade wheel - name: Install project and test dependencies run: | pip install ".[test]" - name: Check types with mypy run: | mypy -p git # With new versions of mypy new issues might arise. This is a problem if there is nobody able to fix them, # so we have to ignore errors until that changes. continue-on-error: true - name: Test with pytest run: | pytest continue-on-error: false - name: Documentation run: | pip install -r doc/requirements.txt make -C doc html GitPython-3.1.37/.gitignore000066400000000000000000000004201450324204500155150ustar00rootroot00000000000000*.py[co] *.swp *~ .env/ env/ .venv/ venv/ /*.egg-info /lib/GitPython.egg-info cover/ .coverage .coverage.* /build /dist /doc/_build nbproject *.sublime-workspace .DS_Store /*egg-info /.tox /.vscode/ .idea/ .cache/ .mypy_cache/ .pytest_cache/ monkeytype.sqlite3 output.txt GitPython-3.1.37/.gitmodules000066400000000000000000000001461450324204500157070ustar00rootroot00000000000000[submodule "gitdb"] url = https://github.com/gitpython-developers/gitdb.git path = git/ext/gitdb GitPython-3.1.37/.pre-commit-config.yaml000066400000000000000000000007261450324204500200170ustar00rootroot00000000000000repos: - repo: https://github.com/PyCQA/flake8 rev: 6.1.0 hooks: - id: flake8 additional_dependencies: [ flake8-bugbear==23.9.16, flake8-comprehensions==3.14.0, flake8-typing-imports==1.14.0, ] exclude: ^doc|^git/ext/ - repo: https://github.com/pre-commit/pre-commit-hooks rev: v4.4.0 hooks: - id: check-merge-conflict - id: check-toml - id: check-yaml GitPython-3.1.37/AUTHORS000066400000000000000000000042301450324204500146000ustar00rootroot00000000000000GitPython 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 -Alan Briolat -Florian Apolloner -David Aguilar -Jelmer Vernooij -Steve Frécinaux -Kai Lautaportti -Paul Sowden -Sebastian Thiel -Jonathan Chu -Vincent Driessen -Phil Elson -Bernard `Guyzmo` Pratz -Timothy B. Hartman -Konstantin Popov -Peter Jones -Anson Mansfield -Ken Odegard -Alexis Horgix Chotard -Piotr Babij -Mikuláš Poul -Charles Bouchard-Légaré -Yaroslav Halchenko -Tim Swast -William Luc Ritchie -David Host -A. Jesse Jiryu Davis -Steven Whitman -Stefan Stancu -César Izurieta -Arthur Milchior -Anil Khatri -JJ Graham -Ben Thayer -Dries Kennes -Pratik Anurag -Harmon -Liam Beguin -Ram Rachum -Alba Mendez -Robert Westman -Hugo van Kemenade -Hiroki Tokunaga -Julien Mauroy -Patrick Gerard -Luke Twist -Joseph Hale -Santos Gallegos -Wenhan Zhu Portions derived from other open source works and are clearly marked. GitPython-3.1.37/CHANGES000066400000000000000000000002211450324204500145170ustar00rootroot00000000000000Please see the online documentation for the latest changelog: https://github.com/gitpython-developers/GitPython/blob/main/doc/source/changes.rst GitPython-3.1.37/CONTRIBUTING.md000066400000000000000000000010321450324204500157560ustar00rootroot00000000000000# How to contribute The following is a short step-by-step rundown of what one typically would do to contribute. - [Fork this project](https://github.com/gitpython-developers/GitPython/fork) on GitHub. - For setting up the environment to run the self tests, please run `init-tests-after-clone.sh`. - Please try to **write a test that fails unless the contribution is present.** - Try to avoid massive commits and prefer to take small steps, with one commit for each. - Feel free to add yourself to AUTHORS file. - Create a pull request. GitPython-3.1.37/LICENSE000066400000000000000000000027371450324204500145470ustar00rootroot00000000000000Copyright (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. GitPython-3.1.37/MANIFEST.in000066400000000000000000000004121450324204500152640ustar00rootroot00000000000000include AUTHORS include CHANGES include CONTRIBUTING.md include LICENSE include README.md include VERSION include requirements.txt include test-requirements.txt include git/py.typed recursive-include doc * recursive-exclude test * global-exclude __pycache__ *.pyc GitPython-3.1.37/Makefile000066400000000000000000000004511450324204500151710ustar00rootroot00000000000000.PHONY: all clean release force_release all: @grep -Ee '^[a-z].*:' Makefile | cut -d: -f1 | grep -vF all clean: rm -rf build/ dist/ .eggs/ .tox/ release: clean ./check-version.sh make force_release force_release: clean ./build-release.sh twine upload dist/* git push --tags origin main GitPython-3.1.37/README.md000066400000000000000000000247501450324204500150200ustar00rootroot00000000000000![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). ## 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=` 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: ```bash 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: ```bash 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: ```bash git clone https://github.com/gitpython-developers/GitPython cd GitPython git fetch --tags ./init-tests-after-clone.sh ``` 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`): ```bash 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): ```bash 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. ### 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 `git fetch --tags` followed by the `./init-tests-after-clone.sh` script in the repository root. Otherwise you will encounter test failures. On _Windows_, make sure you have `git-daemon` in your PATH. For MINGW-git, the `git-daemon.exe` exists in `Git\mingw64\libexec\git-core\`; CYGWIN has no daemon, but should get along fine with MINGW's. #### Install test dependencies Ensure testing libraries are installed. This is taken care of already if you installed with: ```bash pip install -e ".[test]" ``` Otherwise, you can run: ```bash pip install -r test-requirements.txt ``` #### Test commands To test, run: ```bash pytest ``` To lint, run: ```bash pre-commit run --all-files ``` To typecheck, run: ```bash mypy -p git ``` For automatic code formatting, run: ```bash black . ``` Configuration for flake8 is in the `./.flake8` file. Configurations for `mypy`, `pytest`, `coverage.py`, and `black` are in `./pyproject.toml`. The same linting and testing will also be performed against different supported python versions upon submitting a pull request (or on each push if you have a fork with a "main" branch and actions enabled). ### 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 - Update/verify the **version** in the `VERSION` file. - Update/verify that the `doc/source/changes.rst` changelog file was updated. - Commit everything. - Run `git tag -s ` to tag the version in Git. - _Optionally_ create and activate a [virtual environment](https://packaging.python.org/en/latest/guides/installing-using-pip-and-virtual-environments/#creating-a-virtual-environment) using `venv` or `virtualenv`.\ (When run in a virtual environment, the next step will automatically take care of installing `build` and `twine` in it.) - Run `make release`. - Close the milestone mentioned in the _changelog_ and create a new one. _Do not reuse milestones by renaming them_. - Go to [GitHub Releases](https://github.com/gitpython-developers/GitPython/releases) and publish a new one with the recently pushed tag. Generate the changelog. ### How to verify a release (DEPRECATED) Note that what follows is deprecated and future releases won't be signed anymore. More details about how it came to that can be found [in this issue](https://github.com/gitpython-developers/gitdb/issues/77). ---- Please only use releases from `pypi` as you can verify the respective source tarballs. This script shows how to verify the tarball was indeed created by the authors of this project: ```bash curl https://files.pythonhosted.org/packages/09/bc/ae32e07e89cc25b9e5c793d19a1e5454d30a8e37d95040991160f942519e/GitPython-3.1.8-py3-none-any.whl > gitpython.whl curl https://files.pythonhosted.org/packages/09/bc/ae32e07e89cc25b9e5c793d19a1e5454d30a8e37d95040991160f942519e/GitPython-3.1.8-py3-none-any.whl.asc > gitpython-signature.asc gpg --verify gitpython-signature.asc gitpython.whl ``` which outputs ```bash gpg: Signature made Fr 4 Sep 10:04:50 2020 CST gpg: using RSA key 27C50E7F590947D7273A741E85194C08421980C9 gpg: Good signature from "Sebastian Thiel (YubiKey USB-C) " [ultimate] gpg: aka "Sebastian Thiel (In Rust I trust) " [ultimate] ``` You can verify that the keyid indeed matches the release-signature key provided in this repository by looking at the keys details: ```bash gpg --list-packets ./release-verification-key.asc ``` You can verify that the commit adding it was also signed by it using: ```bash git show --show-signature ./release-verification-key.asc ``` If you would like to trust it permanently, you can import and sign it: ```bash gpg --import ./release-verification-key.asc gpg --edit-key 4C08421980C9 > sign > save ``` ### 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 [New BSD License](https://opensource.org/license/bsd-3-clause/). See the [LICENSE file](https://github.com/gitpython-developers/GitPython/blob/main/license). [contributing]: https://github.com/gitpython-developers/GitPython/blob/main/CONTRIBUTING.md [license]: https://github.com/gitpython-developers/GitPython/blob/main/license GitPython-3.1.37/SECURITY.md000066400000000000000000000012701450324204500153220ustar00rootroot00000000000000# Security Policy ## Supported Versions Only the latest version of GitPython can receive security updates. If a vulnerability is discovered, a fix can be issued in a new release, while older releases are likely to be yanked. | Version | Supported | | ------- | ------------------ | | 3.x.x | :white_check_mark: | | < 3.0 | :x: | ## Reporting a Vulnerability Please report private portions of a vulnerability to sebastian.thiel@icloud.com that would help to reproduce and fix it. To receive updates on progress and provide general information to the public, you can create an issue [on the issue tracker](https://github.com/gitpython-developers/GitPython/issues). GitPython-3.1.37/VERSION000066400000000000000000000000071450324204500145760ustar00rootroot000000000000003.1.37 GitPython-3.1.37/build-release.sh000077500000000000000000000015731450324204500166130ustar00rootroot00000000000000#!/bin/bash # # This script builds a release. If run in a venv, it auto-installs its tools. # You may want to run "make release" instead of running this script directly. set -eEu function release_with() { $1 -m build --sdist --wheel } if test -n "${VIRTUAL_ENV:-}"; then deps=(build twine) # Install twine along with build, as we need it later. echo "Virtual environment detected. Adding packages: ${deps[*]}" pip install --quiet --upgrade "${deps[@]}" echo 'Starting the build.' release_with python else function suggest_venv() { venv_cmd='python -m venv env && source env/bin/activate' printf "HELP: To avoid this error, use a virtual-env with '%s' instead.\n" "$venv_cmd" } trap suggest_venv ERR # This keeps the original exit (error) code. echo 'Starting the build.' release_with python3 # Outside a venv, use python3. fi GitPython-3.1.37/check-version.sh000077500000000000000000000037231450324204500166350ustar00rootroot00000000000000#!/bin/bash # # This script checks if we are in a consistent state to build a new release. # See the release instructions in README.md for the steps to make this pass. # You may want to run "make release" instead of running this script directly. set -eEfuo pipefail trap 'echo "$0: Check failed. Stopping." >&2' ERR readonly version_path='VERSION' readonly changes_path='doc/source/changes.rst' echo 'Checking current directory.' test "$(cd -- "$(dirname -- "$0")" && pwd)" = "$(pwd)" # Ugly, but portable. echo "Checking that $version_path and $changes_path exist and have no uncommitted changes." test -f "$version_path" test -f "$changes_path" git status -s -- "$version_path" "$changes_path" test -z "$(git status -s -- "$version_path" "$changes_path")" # This section can be commented out, if absolutely necessary. echo 'Checking that ALL changes are committed.' git status -s --ignore-submodules test -z "$(git status -s --ignore-submodules)" version_version="$(cat "$version_path")" changes_version="$(awk '/^[0-9]/ {print $0; exit}' "$changes_path")" config_opts="$(printf ' -c versionsort.suffix=-%s' alpha beta pre rc RC)" latest_tag="$(git $config_opts tag -l '[0-9]*' --sort=-v:refname | head -n1)" head_sha="$(git rev-parse HEAD)" latest_tag_sha="$(git rev-parse "${latest_tag}^{commit}")" # Display a table of all the current version, tag, and HEAD commit information. echo $'\nThe VERSION must be the same in all locations, and so must the HEAD and tag SHA' printf '%-14s = %s\n' 'VERSION file' "$version_version" \ 'changes.rst' "$changes_version" \ 'Latest tag' "$latest_tag" \ 'HEAD SHA' "$head_sha" \ 'Latest tag SHA' "$latest_tag_sha" # Check that the latest tag and current version match the HEAD we're releasing. test "$version_version" = "$changes_version" test "$latest_tag" = "$version_version" test "$head_sha" = "$latest_tag_sha" echo 'OK, everything looks good.' GitPython-3.1.37/doc/000077500000000000000000000000001450324204500142765ustar00rootroot00000000000000GitPython-3.1.37/doc/.gitignore000066400000000000000000000000071450324204500162630ustar00rootroot00000000000000build/ GitPython-3.1.37/doc/Makefile000066400000000000000000000044531450324204500157440ustar00rootroot00000000000000# Makefile for Sphinx documentation # # You can set these variables from the command line. SPHINXOPTS = -W SPHINXBUILD = sphinx-build PAPER = # Internal variables. PAPEROPT_a4 = -D latex_paper_size=a4 PAPEROPT_letter = -D latex_paper_size=letter ALLSPHINXOPTS = -d build/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source .PHONY: help clean html web pickle htmlhelp latex changes linkcheck help: @echo "Please use \`make ' where is one of" @echo " html to make standalone HTML files" @echo " pickle to make pickle files" @echo " json to make JSON files" @echo " htmlhelp to make HTML files and a HTML help project" @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter" @echo " changes to make an overview over all changed/added/deprecated items" @echo " linkcheck to check all external links for integrity" clean: -rm -rf build/* html: mkdir -p build/html build/doctrees $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) build/html @echo @echo "Build finished. The HTML pages are in build/html." pickle: mkdir -p build/pickle build/doctrees $(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) build/pickle @echo @echo "Build finished; now you can process the pickle files." web: pickle json: mkdir -p build/json build/doctrees $(SPHINXBUILD) -b json $(ALLSPHINXOPTS) build/json @echo @echo "Build finished; now you can process the JSON files." htmlhelp: mkdir -p build/htmlhelp build/doctrees $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) build/htmlhelp @echo @echo "Build finished; now you can run HTML Help Workshop with the" \ ".hhp project file in build/htmlhelp." latex: mkdir -p build/latex build/doctrees $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) build/latex @echo @echo "Build finished; the LaTeX files are in build/latex." @echo "Run \`make all-pdf' or \`make all-ps' in that directory to" \ "run these through (pdf)latex." changes: mkdir -p build/changes build/doctrees $(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) build/changes @echo @echo "The overview file is in build/changes." linkcheck: mkdir -p build/linkcheck build/doctrees $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) build/linkcheck @echo @echo "Link check complete; look for any errors in the above output " \ "or in build/linkcheck/output.txt." GitPython-3.1.37/doc/requirements.txt000066400000000000000000000000701450324204500175570ustar00rootroot00000000000000sphinx==4.3.0 sphinx_rtd_theme sphinx-autodoc-typehints GitPython-3.1.37/doc/source/000077500000000000000000000000001450324204500155765ustar00rootroot00000000000000GitPython-3.1.37/doc/source/changes.rst000066400000000000000000001251551450324204500177510ustar00rootroot00000000000000========= Changelog ========= 3.1.37 ====== This release contains another security fix that further improves validation of symbolic references and thus properly fixes this CVE: https://github.com/advisories/GHSA-cwvm-v4w8-q58c . See the following for all changes. https://github.com/gitpython-developers/gitpython/milestone/67?closed=1 3.1.36 ====== Note that this release should be a no-op, it's mainly for testing the changed release-process. See the following for all changes. https://github.com/gitpython-developers/gitpython/milestone/66?closed=1 3.1.35 ====== See the following for all changes. https://github.com/gitpython-developers/gitpython/milestone/65?closed=1 3.1.34 ====== See the following for all changes. https://github.com/gitpython-developers/gitpython/milestone/64?closed=1 3.1.33 ====== See the following for all changes. https://github.com/gitpython-developers/gitpython/milestone/63?closed=1 3.1.32 ====== See the following for all changes. https://github.com/gitpython-developers/gitpython/milestone/62?closed=1 3.1.31 ====== See the following for all changes. https://github.com/gitpython-developers/gitpython/milestone/61?closed=1 3.1.30 ====== - Make injections of command-invocations harder or impossible for clone and others. See https://github.com/gitpython-developers/GitPython/pull/1518 for details. Note that this might constitute a breaking change for some users, and if so please let us know and we add an opt-out to this. - Prohibit insecure options and protocols by default, which is potentially a breaking change, but a necessary fix for https://github.com/gitpython-developers/GitPython/issues/1515. Please take a look at the PR for more information and how to bypass these protections in case they cause breakage: https://github.com/gitpython-developers/GitPython/pull/1521. See the following for all changes. https://github.com/gitpython-developers/gitpython/milestone/60?closed=1 3.1.29 ====== - Make the git.__version__ re-appear. See the following for all changes. https://github.com/gitpython-developers/gitpython/milestone/59?closed=1 3.1.28 ====== See the following for all changes. https://github.com/gitpython-developers/gitpython/milestone/58?closed=1 3.1.27 ====== - Reduced startup time due to optimized imports. - Fix a vulenerability that could cause great slowdowns when encountering long remote path names when pulling/fetching. See the following for all changes. https://github.com/gitpython-developers/gitpython/milestone/57?closed=1 3.1.26 ====== - Fixes a leaked file descriptor when reading the index, which would cause make writing a previously read index on windows impossible. See https://github.com/gitpython-developers/GitPython/issues/1395 for details. See the following for all changes. https://github.com/gitpython-developers/gitpython/milestone/56?closed=1 3.1.25 ====== See the following for all changes. https://github.com/gitpython-developers/gitpython/milestone/55?closed=1 3.1.24 ====== * Newly added timeout flag is not be enabled by default, and was renamed to kill_after_timeout See the following for details: https://github.com/gitpython-developers/gitpython/milestone/54?closed=1 https://github.com/gitpython-developers/gitpython/milestone/53?closed=1 3.1.23 (YANKED) =============== * This is the second typed release with a lot of improvements under the hood. * General: - Remove python 3.6 support - Remove distutils ahead of deprecation in standard library. - Update sphinx to 4.1.12 and use autodoc-typehints. - Include README as long_description on PyPI - Test against earliest and latest minor version available on Github Actions (e.g. 3.9.0 and 3.9.7) * Typing: - Add types to ALL functions. - Ensure py.typed is collected. - Increase mypy strictness with disallow_untyped_defs, warn_redundant_casts, warn_unreachable. - Use typing.NamedTuple and typing.OrderedDict now 3.6 dropped. - Make Protocol classes ABCs at runtime due to new behaviour/bug in 3.9.7 & 3.10.0-rc1 - Remove use of typing.TypeGuard until later release, to allow dependent libs time to update. - Tracking issue: https://github.com/gitpython-developers/GitPython/issues/1095 * Runtime improvements: - Add clone_multi_options support to submodule.add() - Delay calling get_user_id() unless essential, to support sand-boxed environments. - Add timeout to handle_process_output(), in case thread.join() hangs. See the following for details: https://github.com/gitpython-developers/gitpython/milestone/53?closed=1 3.1.20 (YANKED) =============== * This is the second typed release with a lot of improvements under the hood. * Tracking issue: https://github.com/gitpython-developers/GitPython/issues/1095 See the following for details: https://github.com/gitpython-developers/gitpython/milestone/52?closed=1 3.1.19 (YANKED) =============== * This is the second typed release with a lot of improvements under the hood. * Tracking issue: https://github.com/gitpython-developers/GitPython/issues/1095 See the following for details: https://github.com/gitpython-developers/gitpython/milestone/51?closed=1 3.1.18 ====== * drop support for python 3.5 to reduce maintenance burden on typing. Lower patch levels of python 3.5 would break, too. See the following for details: https://github.com/gitpython-developers/gitpython/milestone/50?closed=1 3.1.17 ====== * Fix issues from 3.1.16 (see https://github.com/gitpython-developers/GitPython/issues/1238) * Fix issues from 3.1.15 (see https://github.com/gitpython-developers/GitPython/issues/1223) * Add more static typing information See the following for details: https://github.com/gitpython-developers/gitpython/milestone/49?closed=1 3.1.16 (YANKED) =============== * Fix issues from 3.1.15 (see https://github.com/gitpython-developers/GitPython/issues/1223) * Add more static typing information See the following for details: https://github.com/gitpython-developers/gitpython/milestone/48?closed=1 3.1.15 (YANKED) =============== * add deprecation warning for python 3.5 See the following for details: https://github.com/gitpython-developers/gitpython/milestone/47?closed=1 3.1.14 ====== * git.Commit objects now have a ``replace`` method that will return a copy of the commit with modified attributes. * Add python 3.9 support * Drop python 3.4 support See the following for details: https://github.com/gitpython-developers/gitpython/milestone/46?closed=1 3.1.13 ====== See the following for details: https://github.com/gitpython-developers/gitpython/milestone/45?closed=1 3.1.12 ====== See the following for details: https://github.com/gitpython-developers/gitpython/milestone/44?closed=1 3.1.11 ====== Fixes regression of 3.1.10. See the following for details: https://github.com/gitpython-developers/gitpython/milestone/43?closed=1 3.1.10 ====== See the following for details: https://github.com/gitpython-developers/gitpython/milestone/42?closed=1 3.1.9 ===== See the following for details: https://github.com/gitpython-developers/gitpython/milestone/41?closed=1 3.1.8 ===== * support for 'includeIf' in git configuration files * tests are now excluded from the package, making it conisderably smaller See the following for more details: https://github.com/gitpython-developers/gitpython/milestone/40?closed=1 3.1.7 ===== * Fix tutorial examples, which disappeared in 3.1.6 due to a missed path change. 3.1.6 ===== * Greatly reduced package size, see https://github.com/gitpython-developers/GitPython/pull/1031 3.1.5 ===== * rollback: package size was reduced significantly not placing tests into the package anymore. See https://github.com/gitpython-developers/GitPython/issues/1030 3.1.4 ===== * all exceptions now keep track of their cause * package size was reduced significantly not placing tests into the package anymore. See the following for details: https://github.com/gitpython-developers/gitpython/milestone/39?closed=1 3.1.3 ===== See the following for details: https://github.com/gitpython-developers/gitpython/milestone/38?closed=1 3.1.2 ===== * Re-release of 3.1.1, with known signature See the following for details: https://github.com/gitpython-developers/gitpython/milestone/37?closed=1 3.1.1 ===== * support for PyOxidizer, which previously failed due to usage of `__file__`. See the following for details: https://github.com/gitpython-developers/gitpython/milestone/36?closed=1 3.1.0 ===== * Switched back to using gitdb package as requirement (`gitdb#59 `_) 3.0.9 ===== * Restricted GitDB (gitdb2) version requirement to < 4 * Removed old nose library from test requirements Bugfixes -------- * Changed to use UTF-8 instead of default encoding when getting information about a symbolic reference (`#774 `_) * Fixed decoding of tag object message so as to replace invalid bytes (`#943 `_) 3.0.8 ===== * Added support for Python 3.8 * Bumped GitDB (gitdb2) version requirement to > 3 Bugfixes -------- * Fixed Repo.__repr__ when subclassed (`#968 `_) * Removed compatibility shims for Python < 3.4 and old mock library * Replaced usage of deprecated unittest aliases and Logger.warn * Removed old, no longer used assert methods * Replaced usage of nose assert methods with unittest 3.0.7 ===== Properly signed re-release of v3.0.6 with new signature (See `#980 `_) 3.0.6 ===== | Note: There was an issue that caused this version to be released to PyPI without a signature | See the changelog for v3.0.7 and `#980 `_ Bugfixes -------- * Fixed warning for usage of environment variables for paths containing ``$`` or ``%`` (`#832 `_, `#961 `_) * Added support for parsing Git internal date format (@ ) (`#965 `_) * Removed Python 2 and < 3.3 compatibility shims (`#979 `_) * Fixed GitDB (gitdb2) requirement version specifier formatting in requirements.txt (`#979 `_) 3.0.5 - Bugfixes ============================================= see the following for details: https://github.com/gitpython-developers/gitpython/milestone/32?closed=1 3.0.4 - Bugfixes ============================================= see the following for details: https://github.com/gitpython-developers/gitpython/milestone/31?closed=1 3.0.3 - Bugfixes ============================================= see the following for (most) details: https://github.com/gitpython-developers/gitpython/milestone/30?closed=1 3.0.2 - Bugfixes ============================================= * fixes an issue with installation 3.0.1 - Bugfixes and performance improvements ============================================= * Fix a `performance regression `__ which could make certain workloads 50% slower * Add `currently_rebasing_on` method on `Repo`, see `the PR `__ * Fix incorrect `requirements.txt` which could lead to broken installations, see this `issue `__ for details. 3.0.0 - Remove Python 2 support =============================== Motivation for this is a patch which improves unicode handling when dealing with filesystem paths. Python 2 compatibility was introduced to deal with differences, and I thought it would be a good idea to 'just' drop support right now, mere 5 months away from the official maintenance stop of python 2.7. The underlying motivation clearly is my anger when thinking python and unicode, which was a hassle from the start, at least in a codebase as old as GitPython, which totally doesn't handle encodings correctly in many cases. Having migrated to using `Rust` exclusively for tooling, I still see that correct handling of encodings isn't entirely trivial, but at least `Rust` makes clear what has to be done at compile time, allowing to write software that is pretty much guaranteed to work once it compiles. Again, my apologies if removing Python 2 support caused inconveniences, please see release 2.1.13 which returns it. see the following for (most) details: https://github.com/gitpython-developers/gitpython/milestone/27?closed=1 or run have a look at the difference between tags v2.1.12 and v3.0.0: https://github.com/gitpython-developers/GitPython/compare/2.1.12...3.0.0. 2.1.15 ====== * Fixed GitDB (gitdb2) requirement version specifier formatting in requirements.txt (Backported from `#979 `_) * Restricted GitDB (gitdb2) version requirement to < 3 (`#897 `_) 2.1.14 ====== * Fixed handling of 0 when transforming kwargs into Git command arguments (Backported from `#899 `_) 2.1.13 - Bring back Python 2.7 support ====================================== My apologies for any inconvenience this may have caused. Following semver, backward incompatible changes will be introduced in a minor version. 2.1.12 - Bugfixes and Features ============================== * Multi-value support and interface improvements for Git configuration. Thanks to A. Jesse Jiryu Davis. or run have a look at the difference between tags v2.1.11 and v2.1.12: https://github.com/gitpython-developers/GitPython/compare/2.1.11...2.1.12 2.1.11 - Bugfixes ================= see the following for (most) details: https://github.com/gitpython-developers/gitpython/milestone/26?closed=1 or run have a look at the difference between tags v2.1.10 and v2.1.11: https://github.com/gitpython-developers/GitPython/compare/2.1.10...2.1.11 2.1.10 - Bugfixes ================= see the following for (most) details: https://github.com/gitpython-developers/gitpython/milestone/25?closed=1 or run have a look at the difference between tags v2.1.9 and v2.1.10: https://github.com/gitpython-developers/GitPython/compare/2.1.9...2.1.10 2.1.9 - Dropping support for Python 2.6 ======================================= see the following for (most) details: https://github.com/gitpython-developers/gitpython/milestone/24?closed=1 or run have a look at the difference between tags v2.1.8 and v2.1.9: https://github.com/gitpython-developers/GitPython/compare/2.1.8...2.1.9 2.1.8 - bugfixes ==================================== see the following for (most) details: https://github.com/gitpython-developers/gitpython/milestone/23?closed=1 or run have a look at the difference between tags v2.1.7 and v2.1.8: https://github.com/gitpython-developers/GitPython/compare/2.1.7...2.1.8 2.1.6 - bugfixes ==================================== * support for worktrees 2.1.3 - Bugfixes ==================================== All issues and PRs can be viewed in all detail when following this URL: https://github.com/gitpython-developers/GitPython/milestone/21?closed=1 2.1.1 - Bugfixes ==================================== All issues and PRs can be viewed in all detail when following this URL: https://github.com/gitpython-developers/GitPython/issues?q=is%3Aclosed+milestone%3A%22v2.1.1+-+Bugfixes%22 2.1.0 - Much better windows support! ==================================== Special thanks to @ankostis, who made this release possible (nearly) single-handedly. GitPython is run by its users, and their PRs make all the difference, they keep GitPython relevant. Thank you all so much for contributing ! Notable fixes ------------- * The `GIT_DIR` environment variable does not override the `path` argument when initializing a `Repo` object anymore. However, if said `path` unset, `GIT_DIR` will be used to fill the void. All issues and PRs can be viewed in all detail when following this URL: https://github.com/gitpython-developers/GitPython/issues?q=is%3Aclosed+milestone%3A%22v2.1.0+-+proper+windows+support%22 2.0.9 - Bugfixes ============================= * `tag.commit` will now resolve commits deeply. * `Repo` objects can now be pickled, which helps with multi-processing. * `Head.checkout()` now deals with detached heads, which is when it will return the `HEAD` reference instead. * `DiffIndex.iter_change_type(...)` produces better results when diffing 2.0.8 - Features and Bugfixes ============================= * `DiffIndex.iter_change_type(...)` produces better results when diffing an index against the working tree. * `Repo().is_dirty(...)` now supports the `path` parameter, to specify a single path by which to filter the output. Similar to `git status ` * Symbolic refs created by this library will now be written with a newline character, which was previously missing. * `blame()` now properly preserves multi-line commit messages. * No longer corrupt ref-logs by writing multi-line comments into them. 2.0.7 - New Features ==================== * `IndexFile.commit(...,skip_hooks=False)` added. This parameter emulates the behaviour of `--no-verify` on the command-line. 2.0.6 - Fixes and Features ========================== * Fix: remote output parser now correctly matches refs with non-ASCII chars in them * API: Diffs now have `a_rawpath`, `b_rawpath`, `raw_rename_from`, `raw_rename_to` properties, which are the raw-bytes equivalents of their unicode path counterparts. * Fix: TypeError about passing keyword argument to string decode() on Python 2.6. * Feature: `setUrl API on Remotes `__ 2.0.5 - Fixes ============= * Fix: parser of fetch info lines choked on some legitimate lines 2.0.4 - Fixes ============= * Fix: parser of commit object data is now robust against cases where commit object contains invalid bytes. The invalid characters are now replaced rather than choked on. * Fix: non-ASCII paths are now properly decoded and returned in ``.diff()`` output * Fix: `RemoteProgress` will now strip the ', ' prefix or suffix from messages. * API: Remote.[fetch|push|pull](...) methods now allow the ``progress`` argument to be a callable. This saves you from creating a custom type with usually just one implemented method. 2.0.3 - Fixes ============= * Fix: bug in ``git-blame --incremental`` output parser that broken when commit messages contained ``\r`` characters * Fix: progress handler exceptions are not caught anymore, which would usually just hide bugs previously. * Fix: The `Git.execute` method will now redirect `stdout` to `devnull` if `with_stdout` is false, which is the intended behaviour based on the parameter's documentation. 2.0.2 - Fixes ============= * Fix: source package does not include \*.pyc files * Fix: source package does include doc sources 2.0.1 - Fixes ============= * Fix: remote output parser now correctly matches refs with "@" in them 2.0.0 - Features ================ Please note that due to breaking changes, we have to increase the major version. * **IMPORTANT**: This release drops support for python 2.6, which is officially deprecated by the python maintainers. * **CRITICAL**: `Diff` objects created with patch output will now not carry the --- and +++ header lines anymore. All diffs now start with the @@ header line directly. Users that rely on the old behaviour can now (reliably) read this information from the a_path and b_path properties without having to parse these lines manually. * `Commit` now has extra properties `authored_datetime` and `committer_datetime` (to get Python datetime instances rather than timestamps) * `Commit.diff()` now supports diffing the root commit via `Commit.diff(NULL_TREE)`. * `Repo.blame()` now respects `incremental=True`, supporting incremental blames. Incremental blames are slightly faster since they don't include the file's contents in them. * Fix: `Diff` objects created with patch output will now have their `a_path` and `b_path` properties parsed out correctly. Previously, some values may have been populated incorrectly when a file was added or deleted. * Fix: diff parsing issues with paths that contain "unsafe" chars, like spaces, tabs, backslashes, etc. 1.0.2 - Fixes ============= * IMPORTANT: Changed default object database of `Repo` objects to `GitCmdObjectDB`. The pure-python implementation used previously usually fails to release its resources (i.e. file handles), which can lead to problems when working with large repositories. * CRITICAL: fixed incorrect `Commit` object serialization when authored or commit date had timezones which were not divisiblej by 3600 seconds. This would happen if the timezone was something like `+0530` for instance. * A list of all additional fixes can be found `on GitHub `__ * CRITICAL: `Tree.cache` was removed without replacement. It is technically impossible to change individual trees and expect their serialization results to be consistent with what *git* expects. Instead, use the `IndexFile` facilities to adjust the content of the staging area, and write it out to the respective tree objects using `IndexFile.write_tree()` instead. 1.0.1 - Fixes ============= * A list of all issues can be found `on GitHub `__ 1.0.0 - Notes ============= This version is equivalent to v0.3.7, but finally acknowledges that GitPython is stable and production ready. It follows the `semantic version scheme `_, and thus will not break its existing API unless it goes 2.0. 0.3.7 - Fixes ============= * `IndexFile.add()` will now write the index without any extension data by default. However, you may override this behaviour with the new `write_extension_data` keyword argument. - Renamed `ignore_tree_extension_data` keyword argument in `IndexFile.write(...)` to `ignore_extension_data` * If the git command executed during `Remote.push(...)|fetch(...)` returns with an non-zero exit code and GitPython didn't obtain any head-information, the corresponding `GitCommandError` will be raised. This may break previous code which expected these operations to never raise. However, that behaviour is undesirable as it would effectively hide the fact that there was an error. See `this issue `__ for more information. * If the git executable can't be found in the PATH or at the path provided by `GIT_PYTHON_GIT_EXECUTABLE`, this is made obvious by throwing `GitCommandNotFound`, both on unix and on windows. - Those who support **GUI on windows** will now have to set `git.Git.USE_SHELL = True` to get the previous behaviour. * A list of all issues can be found `on GitHub `__ 0.3.6 - Features ================ * **DOCS** * special members like `__init__` are now listed in the API documentation * tutorial section was revised entirely, more advanced examples were added. * **POSSIBLY BREAKING CHANGES** * As `rev_parse` will now throw `BadName` as well as `BadObject`, client code will have to catch both exception types. * Repo.working_tree_dir now returns None if it is bare. Previously it raised AssertionError. * IndexFile.add() previously raised AssertionError when paths where used with bare repository, now it raises InvalidGitRepositoryError * Added `Repo.merge_base()` implementation. See the `respective issue on GitHub `__ * `[include]` sections in git configuration files are now respected * Added `GitConfigParser.rename_section()` * Added `Submodule.rename()` * A list of all issues can be found `on GitHub `__ 0.3.5 - Bugfixes ================ * push/pull/fetch operations will not block anymore * diff() can now properly detect renames, both in patch and raw format. Previously it only worked when create_patch was True. * repo.odb.update_cache() is now called automatically after fetch and pull operations. In case you did that in your own code, you might want to remove your line to prevent a double-update that causes unnecessary IO. * `Repo(path)` will not automatically search upstream anymore and find any git directory on its way up. If you need that behaviour, you can turn it back on using the new `search_parent_directories=True` flag when constructing a `Repo` object. * IndexFile.commit() now runs the `pre-commit` and `post-commit` hooks. Verified to be working on posix systems only. * A list of all fixed issues can be found here: https://github.com/gitpython-developers/GitPython/issues?q=milestone%3A%22v0.3.5+-+bugfixes%22+ 0.3.4 - Python 3 Support ======================== * Internally, hexadecimal SHA1 are treated as ascii encoded strings. Binary SHA1 are treated as bytes. * Id attribute of Commit objects is now `hexsha`, instead of `binsha`. The latter makes no sense in python 3 and I see no application of it anyway besides its artificial usage in test cases. * **IMPORTANT**: If you were using the config_writer(), you implicitly relied on __del__ to work as expected to flush changes. To be sure changes are flushed under PY3, you will have to call the new `release()` method to trigger a flush. For some reason, __del__ is not called necessarily anymore when a symbol goes out of scope. * The `Tree` now has a `.join('name')` method which is equivalent to `tree / 'name'` 0.3.3 ===== * When fetching, pulling or pushing, and an error occurs, it will not be reported on stdout anymore. However, if there is a fatal error, it will still result in a GitCommandError to be thrown. This goes hand in hand with improved fetch result parsing. * Code Cleanup (in preparation for python 3 support) * Applied autopep8 and cleaned up code * Using python logging module instead of print statements to signal certain kinds of errors 0.3.2.1 ======= * `Fix for #207 `_ 0.3.2 ===== * Release of most recent version as non-RC build, just to allow pip to install the latest version right away. * Have a look at the milestones (https://github.com/gitpython-developers/GitPython/milestones) to see what's next. 0.3.2 RC1 ========= * **git** command wrapper * Added ``version_info`` property which returns a tuple of integers representing the installed git version. * Added GIT_PYTHON_GIT_EXECUTABLE environment variable, which can be used to set the desired git executable to be used. despite of what would be found in the path. * **Blob** Type * Added mode constants to ease the manual creation of blobs * **IterableList** * Added __contains__ and __delitem__ methods * **More Changes** * Configuration file parsing is more robust. It should now be able to handle everything that the git command can parse as well. * The progress parsing was updated to support git 1.7.0.3 and newer. Previously progress was not enabled for the git command or only worked with ssh in case of older git versions. * Parsing of tags was improved. Previously some parts of the name could not be parsed properly. * The rev-parse pure python implementation now handles branches correctly if they look like hexadecimal sha's. * GIT_PYTHON_TRACE is now set on class level of the Git type, previously it was a module level global variable. * GIT_PYTHON_GIT_EXECUTABLE is a class level variable as well. 0.3.1 Beta 2 ============ * Added **reflog support** ( reading and writing ) * New types: ``RefLog`` and ``RefLogEntry`` * Reflog is maintained automatically when creating references and deleting them * Non-intrusive changes to ``SymbolicReference``, these don't require your code to change. They allow to append messages to the reflog. * ``abspath`` property added, similar to ``abspath`` of Object instances * ``log()`` method added * ``log_append(...)`` method added * ``set_reference(...)`` method added (reflog support) * ``set_commit(...)`` method added (reflog support) * ``set_object(...)`` method added (reflog support) * **Intrusive Changes** to ``Head`` type * ``create(...)`` method now supports the reflog, but will not raise ``GitCommandError`` anymore as it is a pure python implementation now. Instead, it raises ``OSError``. * **Intrusive Changes** to ``Repo`` type * ``create_head(...)`` method does not support kwargs anymore, instead it supports a logmsg parameter * Repo.rev_parse now supports the [ref]@{n} syntax, where *n* is the number of steps to look into the reference's past * **BugFixes** * Removed incorrect ORIG_HEAD handling * **Flattened directory** structure to make development more convenient. * .. note:: This alters the way projects using git-python as a submodule have to adjust their sys.path to be able to import git-python successfully. * Misc smaller changes and bugfixes 0.3.1 Beta 1 ============ * Full Submodule-Support * Added unicode support for author names. Commit.author.name is now unicode instead of string. * Head Type changes * config_reader() & config_writer() methods added for access to head specific options. * tracking_branch() & set_tracking_branch() methods added for easy configuration of tracking branches. 0.3.0 Beta 2 ============ * Added python 2.4 support 0.3.0 Beta 1 ============ Renamed Modules --------------- * For consistency with naming conventions used in sub-modules like gitdb, the following modules have been renamed * git.utils -> git.util * git.errors -> git.exc * git.objects.utils -> git.objects.util General ------- * Object instances, and everything derived from it, now use binary sha's internally. The 'sha' member was removed, in favor of the 'binsha' member. An 'hexsha' property is available for convenient conversions. They may only be initialized using their binary shas, reference names or revision specs are not allowed anymore. * IndexEntry instances contained in IndexFile.entries now use binary sha's. Use the .hexsha property to obtain the hexadecimal version. The .sha property was removed to make the use of the respective sha more explicit. * If objects are instantiated explicitly, a binary sha is required to identify the object, where previously any rev-spec could be used. The ref-spec compatible version still exists as Object.new or Repo.commit|Repo.tree respectively. * The .data attribute was removed from the Object type, to obtain plain data, use the data_stream property instead. * ConcurrentWriteOperation was removed, and replaced by LockedFD * IndexFile.get_entries_key was renamed to entry_key * IndexFile.write_tree: removed missing_ok keyword, its always True now. Instead of raising GitCommandError it raises UnmergedEntriesError. This is required as the pure-python implementation doesn't support the missing_ok keyword yet. * diff.Diff.null_hex_sha renamed to NULL_HEX_SHA, to be conforming with the naming in the Object base class 0.2 Beta 2 =========== * Commit objects now carry the 'encoding' information of their message. It wasn't parsed previously, and defaults to UTF-8 * Commit.create_from_tree now uses a pure-python implementation, mimicking git-commit-tree 0.2 ===== General ------- * file mode in Tree, Blob and Diff objects now is an int compatible to definitions in the stat module, allowing you to query whether individual user, group and other read, write and execute bits are set. * Adjusted class hierarchy to generally allow comparison and hash for Objects and Refs * Improved Tag object which now is a Ref that may contain a tag object with additional Information * id_abbrev method has been removed as it could not assure the returned short SHA's where unique * removed basename method from Objects with path's as it replicated features of os.path * from_string and list_from_string methods are now private and were renamed to _from_string and _list_from_string respectively. As part of the private API, they may change without prior notice. * Renamed all find_all methods to list_items - this method is part of the Iterable interface that also provides a more efficients and more responsive iter_items method * All dates, like authored_date and committer_date, are stored as seconds since epoch to consume less memory - they can be converted using time.gmtime in a more suitable presentation format if needed. * Named method parameters changed on a wide scale to unify their use. Now git specific terms are used everywhere, such as "Reference" ( ref ) and "Revision" ( rev ). Previously multiple terms where used making it harder to know which type was allowed or not. * Unified diff interface to allow easy diffing between trees, trees and index, trees and working tree, index and working tree, trees and index. This closely follows the git-diff capabilities. * Git.execute does not take the with_raw_output option anymore. It was not used by anyone within the project and False by default. Item Iteration -------------- * Previously one would return and process multiple items as list only which can hurt performance and memory consumption and reduce response times. iter_items method provide an iterator that will return items on demand as parsed from a stream. This way any amount of objects can be handled. * list_items method returns IterableList allowing to access list members by name objects Package ---------------- * blob, tree, tag and commit module have been moved to new objects package. This should not affect you though unless you explicitly imported individual objects. If you just used the git package, names did not change. Blob ---- * former 'name' member renamed to path as it suits the actual data better GitCommand ----------- * git.subcommand call scheme now prunes out None from the argument list, allowing to be called more comfortably as None can never be a valid to the git command if converted to a string. * Renamed 'git_dir' attribute to 'working_dir' which is exactly how it is used Commit ------ * 'count' method is not an instance method to increase its ease of use * 'name_rev' property returns a nice name for the commit's sha Config ------ * The git configuration can now be read and manipulated directly from within python using the GitConfigParser * Repo.config_reader() returns a read-only parser * Repo.config_writer() returns a read-write parser Diff ---- * Members a a_commit and b_commit renamed to a_blob and b_blob - they are populated with Blob objects if possible * Members a_path and b_path removed as this information is kept in the blobs * Diffs are now returned as DiffIndex allowing to more quickly find the kind of diffs you are interested in Diffing ------- * Commit and Tree objects now support diffing natively with a common interface to compare against other Commits or Trees, against the working tree or against the index. Index ----- * A new Index class allows to read and write index files directly, and to perform simple two and three way merges based on an arbitrary index. References ------------ * References are object that point to a Commit * SymbolicReference are a pointer to a Reference Object, which itself points to a specific Commit * They will dynamically retrieve their object at the time of query to assure the information is actual. Recently objects would be cached, hence ref object not be safely kept persistent. Repo ---- * Moved blame method from Blob to repo as it appeared to belong there much more. * active_branch method now returns a Head object instead of a string with the name of the active branch. * tree method now requires a Ref instance as input and defaults to the active_branch instead of master * is_dirty now takes additional arguments allowing fine-grained control about what is considered dirty * Removed the following methods: - 'log' method as it as effectively the same as the 'commits' method - 'commits_since' as it is just a flag given to rev-list in Commit.iter_items - 'commit_count' as it was just a redirection to the respective commit method - 'commits_between', replaced by a note on the iter_commits method as it can achieve the same thing - 'commit_delta_from' as it was a very special case by comparing two different repjrelated repositories, i.e. clones, git-rev-list would be sufficient to find commits that would need to be transferred for example. - 'create' method which equals the 'init' method's functionality - 'diff' - it returned a mere string which still had to be parsed - 'commit_diff' - moved to Commit, Tree and Diff types respectively * Renamed the following methods: - commits to iter_commits to improve the performance, adjusted signature - init_bare to init, implying less about the options to be used - fork_bare to clone, as it was to represent general clone functionality, but implied a bare clone to be more versatile - archive_tar_gz and archive_tar and replaced by archive method with different signature * 'commits' method has no max-count of returned commits anymore, it now behaves like git-rev-list * The following methods and properties were added - 'untracked_files' property, returning all currently untracked files - 'head', creates a head object - 'tag', creates a tag object - 'iter_trees' method - 'config_reader' method - 'config_writer' method - 'bare' property, previously it was a simple attribute that could be written * Renamed the following attributes - 'path' is now 'git_dir' - 'wd' is now 'working_dir' * Added attribute - 'working_tree_dir' which may be None in case of bare repositories Remote ------ * Added Remote object allowing easy access to remotes * Repo.remotes lists all remotes * Repo.remote returns a remote of the specified name if it exists Test Framework -------------- * Added support for common TestCase base class that provides additional functionality to receive repositories tests can also write to. This way, more aspects can be tested under real-world ( un-mocked ) conditions. Tree ---- * former 'name' member renamed to path as it suits the actual data better * added traverse method allowing to recursively traverse tree items * deleted blob method * added blobs and trees properties allowing to query the respective items in the tree * now mimics behaviour of a read-only list instead of a dict to maintain order. * content_from_string method is now private and not part of the public API anymore 0.1.6 ===== General ------- * Added in Sphinx documentation. * Removed ambiguity between paths and treeishs. When calling commands that accept treeish and path arguments and there is a path with the same name as a treeish git cowardly refuses to pick one and asks for the command to use the unambiguous syntax where '--' separates the treeish from the paths. * ``Repo.commits``, ``Repo.commits_between``, ``Repo.commits_since``, ``Repo.commit_count``, ``Repo.commit``, ``Commit.count`` and ``Commit.find_all`` all now optionally take a path argument which constrains the lookup by path. This changes the order of the positional arguments in ``Repo.commits`` and ``Repo.commits_since``. Commit ------ * ``Commit.message`` now contains the full commit message (rather than just the first line) and a new property ``Commit.summary`` contains the first line of the commit message. * Fixed a failure when trying to lookup the stats of a parentless commit from a bare repo. Diff ---- * The diff parser is now far faster and also addresses a bug where sometimes b_mode was not set. * Added support for parsing rename info to the diff parser. Addition of new properties ``Diff.renamed``, ``Diff.rename_from``, and ``Diff.rename_to``. Head ---- * Corrected problem where branches was only returning the last path component instead of the entire path component following refs/heads/. Repo ---- * Modified the gzip archive creation to use the python gzip module. * Corrected ``commits_between`` always returning None instead of the reversed list. 0.1.5 ===== General ------- * upgraded to Mock 0.4 dependency. * Replace GitPython with git in repr() outputs. * Fixed packaging issue caused by ez_setup.py. Blob ---- * No longer strip newlines from Blob data. Commit ------ * Corrected problem with git-rev-list --bisect-all. See http://groups.google.com/group/git-python/browse_thread/thread/aed1d5c4b31d5027 Repo ---- * Corrected problems with creating bare repositories. * Repo.tree no longer accepts a path argument. Use: >>> dict(k, o for k, o in tree.items() if k in paths) * Made daemon export a property of Repo. Now you can do this: >>> exported = repo.daemon_export >>> repo.daemon_export = True * Allows modifying the project description. Do this: >>> repo.description = "Foo Bar" >>> repo.description 'Foo Bar' * Added a read-only property Repo.is_dirty which reflects the status of the working directory. * Added a read-only Repo.active_branch property which returns the name of the currently active branch. Tree ---- * Switched to using a dictionary for Tree contents since you will usually want to access them by name and order is unimportant. * Implemented a dictionary protocol for Tree objects. The following: child = tree.contents['grit'] becomes: child = tree['grit'] * Made Tree.content_from_string a static method. 0.1.4.1 ======= * removed ``method_missing`` stuff and replaced with a ``__getattr__`` override in ``Git``. 0.1.4 ===== * renamed ``git_python`` to ``git``. Be sure to delete all pyc files before testing. Commit ------ * Fixed problem with commit stats not working under all conditions. Git --- * Renamed module to cmd. * Removed shell escaping completely. * Added support for ``stderr``, ``stdin``, and ``with_status``. * ``git_dir`` is now optional in the constructor for ``git.Git``. Git now falls back to ``os.getcwd()`` when git_dir is not specified. * add a ``with_exceptions`` keyword argument to git commands. ``GitCommandError`` is raised when the exit status is non-zero. * add support for a ``GIT_PYTHON_TRACE`` environment variable. ``GIT_PYTHON_TRACE`` allows us to debug GitPython's usage of git through the use of an environment variable. Tree ---- * Fixed up problem where ``name`` doesn't exist on root of tree. Repo ---- * Corrected problem with creating bare repo. Added ``Repo.create`` alias. 0.1.2 ===== Tree ---- * Corrected problem with ``Tree.__div__`` not working with zero length files. Removed ``__len__`` override and replaced with size instead. Also made size cache properly. This is a breaking change. 0.1.1 ===== Fixed up some urls because I'm a moron 0.1.0 ===== initial release GitPython-3.1.37/doc/source/conf.py000066400000000000000000000140021450324204500170720ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # GitPython documentation build configuration file, created by # sphinx-quickstart on Sat Jan 24 11:51:01 2009. # # This file is execfile()d with the current directory set to its containing dir. # # The contents of this file are pickled, so don't put values in the namespace # that aren't pickleable (module imports are okay, they're removed automatically). # # Note that not all possible configuration values are present in this # autogenerated file. # # All configuration values have a default; values that are commented out # serve to show the default. import sys import os # If your extensions are in another directory, add it here. If the directory # is relative to the documentation root, use os.path.abspath to make it # absolute, like shown here. # sys.path.append(os.path.abspath('.')) sys.path.insert(0, os.path.abspath("../..")) # General configuration # --------------------- # Add any Sphinx extension module names here, as strings. They can be extensions # coming with Sphinx (named 'sphinx.ext.*') or your custom ones. extensions = ["sphinx.ext.autodoc", "sphinx.ext.doctest"] # Add any paths that contain templates here, relative to this directory. templates_path = [] # The suffix of source filenames. source_suffix = ".rst" # The encoding of source files. # source_encoding = 'utf-8' # The master toctree document. master_doc = "index" # General information about the project. project = "GitPython" copyright = "Copyright (C) 2008, 2009 Michael Trier and contributors, 2010-2015 Sebastian Thiel" # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the # built documents. # # The short X.Y version. with open(os.path.join(os.path.dirname(__file__), "..", "..", "VERSION")) as fd: VERSION = fd.readline().strip() version = VERSION # The full version, including alpha/beta/rc tags. release = VERSION # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. # language = None # There are two options for replacing |today|: either, you set today to some # non-false value, then it is used: # today = '' # Else, today_fmt is used as the format for a strftime call. # today_fmt = '%B %d, %Y' # List of documents that shouldn't be included in the build. # unused_docs = [] # List of directories, relative to source directory, that shouldn't be searched # for source files. exclude_trees = ["build"] # The reST default role (used for this markup: `text`) to use for all documents. # default_role = None # If true, '()' will be appended to :func: etc. cross-reference text. # add_function_parentheses = True # If true, the current module name will be prepended to all description # unit titles (such as .. function::). # add_module_names = True # If true, sectionauthor and moduleauthor directives will be shown in the # output. They are ignored by default. # show_authors = False # The name of the Pygments (syntax highlighting) style to use. pygments_style = "sphinx" # Options for HTML output # ----------------------- html_theme = "sphinx_rtd_theme" html_theme_options = {} # The name for this set of Sphinx documents. If None, it defaults to # " v documentation". # html_title = None # A shorter title for the navigation bar. Default is the same as html_title. # html_short_title = None # The name of an image file (relative to this directory) to place at the top # of the sidebar. # html_logo = None # The name of an image file (within the static path) to use as favicon of the # docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 # pixels large. # html_favicon = None # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = [] # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, # using the given strftime format. # html_last_updated_fmt = '%b %d, %Y' # If true, SmartyPants will be used to convert quotes and dashes to # typographically correct entities. # html_use_smartypants = True # Custom sidebar templates, maps document names to template names. # html_sidebars = {} # Additional templates that should be rendered to pages, maps page names to # template names. # html_additional_pages = {} # If false, no module index is generated. # html_use_modindex = True # If false, no index is generated. # html_use_index = True # If true, the index is split into individual pages for each letter. # html_split_index = False # If true, the reST sources are included in the HTML build as _sources/. # html_copy_source = True # If true, an OpenSearch description file will be output, and all pages will # contain a tag referring to it. The value of this option must be the # base URL from which the finished HTML is served. # html_use_opensearch = '' # If nonempty, this is the file name suffix for HTML files (e.g. ".xhtml"). # html_file_suffix = '' # Output file base name for HTML help builder. htmlhelp_basename = "gitpythondoc" # Options for LaTeX output # ------------------------ # The paper size ('letter' or 'a4'). # latex_paper_size = 'letter' # The font size ('10pt', '11pt' or '12pt'). # latex_font_size = '10pt' # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, author, document class [howto/manual]). latex_documents = [ ("index", "GitPython.tex", r"GitPython Documentation", r"Michael Trier", "manual"), ] # The name of an image file (relative to this directory) to place at the top of # the title page. # latex_logo = None # For "manual" documents, if this is true, then toplevel headings are parts, # not chapters. # latex_use_parts = False # Additional stuff for the LaTeX preamble. # latex_preamble = '' # Documents to append as an appendix to all manuals. # latex_appendices = [] # If false, no module index is generated. # latex_use_modindex = True GitPython-3.1.37/doc/source/index.rst000066400000000000000000000007131450324204500174400ustar00rootroot00000000000000.. GitPython documentation master file, created by sphinx-quickstart on Sat Jan 24 11:51:01 2009. You can adapt this file completely to your liking, but it should at least contain the root `toctree` directive. GitPython Documentation ======================= .. toctree:: :maxdepth: 2 intro quickstart tutorial reference roadmap changes Indices and tables ================== * :ref:`genindex` * :ref:`modindex` * :ref:`search` GitPython-3.1.37/doc/source/intro.rst000066400000000000000000000077121450324204500174720ustar00rootroot00000000000000.. _intro_toplevel: ================== Overview / Install ================== 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, and additionally allows you to access the git repository more directly using either a pure python implementation, or the faster, but more resource intensive git command implementation. The object database implementation is optimized for handling large quantities of objects and large datasets, which is achieved by using low-level structures and data streaming. Requirements ============ * `Python`_ >= 3.7 * `Git`_ 1.7.0 or newer It should also work with older versions, but it may be that some operations involving remotes will not work as expected. * `GitDB`_ - a pure python git database implementation * `typing_extensions`_ >= 3.7.3.4 (if python < 3.10) .. _Python: https://www.python.org .. _Git: https://git-scm.com/ .. _GitDB: https://pypi.python.org/pypi/gitdb .. _typing_extensions: https://pypi.org/project/typing-extensions/ Installing GitPython ==================== Installing GitPython is easily done using `pip`_. Assuming it is installed, just run the following from the command-line: .. sourcecode:: none # pip install GitPython This command will download the latest version of GitPython from the `Python Package Index `_ and install it to your system. More information about ``pip`` and pypi can be found here: * `install pip `_ * `pypi `_ .. _pip: https://pip.pypa.io/en/latest/installing.html Alternatively, you can install from the distribution using the ``setup.py`` script: .. sourcecode:: none # python setup.py install .. note:: In this case, you have to manually install `GitDB`_ as well. It would be recommended to use the :ref:`git source repository ` in that case. 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. Getting Started =============== * :ref:`tutorial-label` - This tutorial provides a walk-through of some of the basic functionality and concepts used in GitPython. It, however, is not exhaustive so you are encouraged to spend some time in the :ref:`api_reference_toplevel`. API Reference ============= An organized section of the GitPython API is at :ref:`api_reference_toplevel`. .. _source-code-label: Source Code =========== GitPython's git repo is available on GitHub, which can be browsed at: * https://github.com/gitpython-developers/GitPython and cloned using:: $ git clone https://github.com/gitpython-developers/GitPython git-python Initialize all submodules to obtain the required dependencies with:: $ cd git-python $ git submodule update --init --recursive Finally verify the installation by running unit tests:: $ python -m unittest Questions and Answers ===================== Please use stackoverflow for questions, and don't forget to tag it with `gitpython` to assure the right people see the question in a timely manner. http://stackoverflow.com/questions/tagged/gitpython Issue Tracker ============= The issue tracker is hosted by GitHub: https://github.com/gitpython-developers/GitPython/issues License Information =================== GitPython is licensed under the New BSD License. See the LICENSE file for more information. GitPython-3.1.37/doc/source/quickstart.rst000066400000000000000000000165731450324204500205360ustar00rootroot00000000000000.. _quickdoc_toplevel: .. highlight:: python .. _quickdoc-label: ============================== GitPython Quick Start Tutorial ============================== Welcome to the GitPython Quickstart Guide! Designed for developers seeking a practical and interactive learning experience, this concise resource offers step-by-step code snippets to swiftly initialize/clone repositories, perform essential Git operations, and explore GitPython's capabilities. Get ready to dive in, experiment, and unleash the power of GitPython in your projects! git.Repo ******** There are a few ways to create a :class:`git.Repo ` object Initialize a new git Repo ######################### .. literalinclude:: ../../test/test_quick_doc.py :language: python :dedent: 8 :start-after: # [1-test_init_repo_object] :end-before: # ![1-test_init_repo_object] Existing local git Repo ####################### .. literalinclude:: ../../test/test_quick_doc.py :language: python :dedent: 8 :start-after: # [2-test_init_repo_object] :end-before: # ![2-test_init_repo_object] Clone from URL ############## For the rest of this tutorial we will use a clone from https://github.com/gitpython-developers/QuickStartTutorialFiles.git .. literalinclude:: ../../test/test_quick_doc.py :language: python :dedent: 8 :start-after: # [1-test_cloned_repo_object] :end-before: # ![1-test_cloned_repo_object] Trees & Blobs ************** Latest Commit Tree ################## .. literalinclude:: ../../test/test_quick_doc.py :language: python :dedent: 8 :start-after: # [12-test_cloned_repo_object] :end-before: # ![12-test_cloned_repo_object] Any Commit Tree ############### .. literalinclude:: ../../test/test_quick_doc.py :language: python :dedent: 8 :start-after: # [13-test_cloned_repo_object] :end-before: # ![13-test_cloned_repo_object] Display level 1 Contents ######################## .. literalinclude:: ../../test/test_quick_doc.py :language: python :dedent: 8 :start-after: # [14-test_cloned_repo_object] :end-before: # ![14-test_cloned_repo_object] Recurse through the Tree ######################## .. literalinclude:: ../../test/test_quick_doc.py :language: python :dedent: 8 :start-after: # [15-test_cloned_repo_object] :end-before: # ![15-test_cloned_repo_object] .. literalinclude:: ../../test/test_quick_doc.py :language: python :dedent: 8 :start-after: # [16-test_cloned_repo_object] :end-before: # ![16-test_cloned_repo_object] Usage **************** Add file to staging area ######################## .. literalinclude:: ../../test/test_quick_doc.py :language: python :dedent: 8 :start-after: # [2-test_cloned_repo_object] :end-before: # ![2-test_cloned_repo_object] Now lets add the updated file to git .. literalinclude:: ../../test/test_quick_doc.py :language: python :dedent: 8 :start-after: # [3-test_cloned_repo_object] :end-before: # ![3-test_cloned_repo_object] Notice the add method requires a list as a parameter Warning: If you experience any trouble with this, try to invoke :class:`git ` instead via repo.git.add(path) Commit ###### .. literalinclude:: ../../test/test_quick_doc.py :language: python :dedent: 8 :start-after: # [4-test_cloned_repo_object] :end-before: # ![4-test_cloned_repo_object] List of commits associated with a file ####################################### .. literalinclude:: ../../test/test_quick_doc.py :language: python :dedent: 8 :start-after: # [5-test_cloned_repo_object] :end-before: # ![5-test_cloned_repo_object] Notice this returns a generator object .. literalinclude:: ../../test/test_quick_doc.py :language: python :dedent: 8 :start-after: # [6-test_cloned_repo_object] :end-before: # ![6-test_cloned_repo_object] returns list of :class:`Commit ` objects Printing text files #################### Lets print the latest version of `/dir1/file2.txt` .. literalinclude:: ../../test/test_quick_doc.py :language: python :dedent: 8 :start-after: # [17-test_cloned_repo_object] :end-before: # ![17-test_cloned_repo_object] .. literalinclude:: ../../test/test_quick_doc.py :language: python :dedent: 8 :start-after: # [18-test_cloned_repo_object] :end-before: # ![18-test_cloned_repo_object] Previous version of `/dir1/file2.txt` .. literalinclude:: ../../test/test_quick_doc.py :language: python :dedent: 8 :start-after: # [18.1-test_cloned_repo_object] :end-before: # ![18.1-test_cloned_repo_object] Status ###### * Untracked files Lets create a new file .. literalinclude:: ../../test/test_quick_doc.py :language: python :dedent: 8 :start-after: # [7-test_cloned_repo_object] :end-before: # ![7-test_cloned_repo_object] .. literalinclude:: ../../test/test_quick_doc.py :language: python :dedent: 8 :start-after: # [8-test_cloned_repo_object] :end-before: # ![8-test_cloned_repo_object] * Modified files .. literalinclude:: ../../test/test_quick_doc.py :language: python :dedent: 8 :start-after: # [9-test_cloned_repo_object] :end-before: # ![9-test_cloned_repo_object] .. literalinclude:: ../../test/test_quick_doc.py :language: python :dedent: 8 :start-after: # [10-test_cloned_repo_object] :end-before: # ![10-test_cloned_repo_object] returns a list of :class:`Diff ` objects .. literalinclude:: ../../test/test_quick_doc.py :language: python :dedent: 8 :start-after: # [11-test_cloned_repo_object] :end-before: # ![11-test_cloned_repo_object] Diffs ###### Compare staging area to head commit .. literalinclude:: ../../test/test_quick_doc.py :language: python :dedent: 8 :start-after: # [11.1-test_cloned_repo_object] :end-before: # ![11.1-test_cloned_repo_object] .. literalinclude:: ../../test/test_quick_doc.py :language: python :dedent: 8 :start-after: # [11.2-test_cloned_repo_object] :end-before: # ![11.2-test_cloned_repo_object] Compare commit to commit .. literalinclude:: ../../test/test_quick_doc.py :language: python :dedent: 8 :start-after: # [11.3-test_cloned_repo_object] :end-before: # ![11.3-test_cloned_repo_object] More Resources **************** Remember, this is just the beginning! There's a lot more you can achieve with GitPython in your development workflow. To explore further possibilities and discover advanced features, check out the full :ref:`GitPython tutorial ` and the :ref:`API Reference `. Happy coding! GitPython-3.1.37/doc/source/reference.rst000066400000000000000000000063671450324204500203020ustar00rootroot00000000000000.. _api_reference_toplevel: API Reference ============= Version ------- .. py:data:: git.__version__ Current GitPython version. Objects.Base ------------ .. automodule:: git.objects.base :members: :undoc-members: :special-members: Objects.Blob ------------ .. automodule:: git.objects.blob :members: :undoc-members: :special-members: Objects.Commit -------------- .. automodule:: git.objects.commit :members: :undoc-members: :special-members: Objects.Tag ----------- .. automodule:: git.objects.tag :members: :undoc-members: :special-members: Objects.Tree ------------ .. automodule:: git.objects.tree :members: :undoc-members: :special-members: Objects.Functions ----------------- .. automodule:: git.objects.fun :members: :undoc-members: :special-members: Objects.Submodule.base ---------------------- .. automodule:: git.objects.submodule.base :members: :undoc-members: :special-members: Objects.Submodule.root ---------------------- .. automodule:: git.objects.submodule.root :members: :undoc-members: :special-members: Objects.Submodule.util ---------------------- .. automodule:: git.objects.submodule.util :members: :undoc-members: :special-members: Objects.Util ------------- .. automodule:: git.objects.util :members: :undoc-members: :special-members: Index.Base ---------- .. automodule:: git.index.base :members: :undoc-members: :special-members: Index.Functions --------------- .. automodule:: git.index.fun :members: :undoc-members: :special-members: Index.Types ----------- .. automodule:: git.index.typ :members: :undoc-members: :special-members: Index.Util ------------- .. automodule:: git.index.util :members: :undoc-members: :special-members: GitCmd ------ .. automodule:: git.cmd :members: :undoc-members: :special-members: Config ------ .. automodule:: git.config :members: :undoc-members: :special-members: Diff ---- .. automodule:: git.diff :members: :undoc-members: :special-members: Exceptions ---------- .. automodule:: git.exc :members: :undoc-members: :special-members: Refs.symbolic ------------- .. automodule:: git.refs.symbolic :members: :undoc-members: :special-members: Refs.reference -------------- .. automodule:: git.refs.reference :members: :undoc-members: :special-members: Refs.head --------- .. automodule:: git.refs.head :members: :undoc-members: :special-members: Refs.tag ------------ .. automodule:: git.refs.tag :members: :undoc-members: :special-members: Refs.remote ------------ .. automodule:: git.refs.remote :members: :undoc-members: :special-members: Refs.log ------------ .. automodule:: git.refs.log :members: :undoc-members: :special-members: Remote ------ .. automodule:: git.remote :members: :undoc-members: :special-members: Repo.Base --------- .. automodule:: git.repo.base :members: :undoc-members: :special-members: Repo.Functions -------------- .. automodule:: git.repo.fun :members: :undoc-members: :special-members: Util ---- .. automodule:: git.util :members: :undoc-members: :special-members: GitPython-3.1.37/doc/source/roadmap.rst000066400000000000000000000003551450324204500177560ustar00rootroot00000000000000 ####### Roadmap ####### The full list of milestones including associated tasks can be found on GitHub: https://github.com/gitpython-developers/GitPython/issues Select the respective milestone to filter the list of issues accordingly. GitPython-3.1.37/doc/source/tutorial.rst000066400000000000000000000600551450324204500202010ustar00rootroot00000000000000.. _tutorial_toplevel: .. highlight:: python .. _tutorial-label: ================== GitPython Tutorial ================== GitPython provides object model access to your git repository. This tutorial is composed of multiple sections, most of which explain a real-life use case. All code presented here originated from `test_docs.py `_ to assure correctness. Knowing this should also allow you to more easily run the code for your own testing purposes. All you need is a developer installation of git-python. Meet the Repo type ****************** The first step is to create a :class:`git.Repo ` object to represent your repository. .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [1-test_init_repo_object] :end-before: # ![1-test_init_repo_object] In the above example, the directory ``self.rorepo.working_tree_dir`` equals ``/Users/mtrier/Development/git-python`` and is my working repository which contains the ``.git`` directory. You can also initialize GitPython with a *bare* repository. .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [2-test_init_repo_object] :end-before: # ![2-test_init_repo_object] A repo object provides high-level access to your data, it allows you to create and delete heads, tags and remotes and access the configuration of the repository. .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [3-test_init_repo_object] :end-before: # ![3-test_init_repo_object] Query the active branch, query untracked files or whether the repository data has been modified. .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [4-test_init_repo_object] :end-before: # ![4-test_init_repo_object] Clone from existing repositories or initialize new empty ones. .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [5-test_init_repo_object] :end-before: # ![5-test_init_repo_object] Archive the repository contents to a tar file. .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [6-test_init_repo_object] :end-before: # ![6-test_init_repo_object] Advanced Repo Usage =================== And of course, there is much more you can do with this type, most of the following will be explained in greater detail in specific tutorials. Don't worry if you don't understand some of these examples right away, as they may require a thorough understanding of git's inner workings. Query relevant repository paths ... .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [7-test_init_repo_object] :end-before: # ![7-test_init_repo_object] :class:`Heads ` Heads are branches in git-speak. :class:`References ` are pointers to a specific commit or to other references. Heads and :class:`Tags ` are a kind of references. GitPython allows you to query them rather intuitively. .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [8-test_init_repo_object] :end-before: # ![8-test_init_repo_object] You can also create new heads ... .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [9-test_init_repo_object] :end-before: # ![9-test_init_repo_object] ... and tags ... .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [10-test_init_repo_object] :end-before: # ![10-test_init_repo_object] You can traverse down to :class:`git objects ` through references and other objects. Some objects like :class:`commits ` have additional meta-data to query. .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [11-test_init_repo_object] :end-before: # ![11-test_init_repo_object] :class:`Remotes ` allow to handle fetch, pull and push operations, while providing optional real-time progress information to :class:`progress delegates `. .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [12-test_init_repo_object] :end-before: # ![12-test_init_repo_object] The :class:`index ` is also called stage in git-speak. It is used to prepare new commits, and can be used to keep results of merge operations. Our index implementation allows to stream date into the index, which is useful for bare repositories that do not have a working tree. .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [13-test_init_repo_object] :end-before: # ![13-test_init_repo_object] :class:`Submodules ` represent all aspects of git submodules, which allows you query all of their related information, and manipulate in various ways. .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [14-test_init_repo_object] :end-before: # ![14-test_init_repo_object] Examining References ******************** :class:`References ` are the tips of your commit graph from which you can easily examine the history of your project. .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [1-test_references_and_objects] :end-before: # ![1-test_references_and_objects] :class:`Tags ` are (usually immutable) references to a commit and/or a tag object. .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [2-test_references_and_objects] :end-before: # ![2-test_references_and_objects] A :class:`symbolic reference ` is a special case of a reference as it points to another reference instead of a commit. .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [3-test_references_and_objects] :end-before: # ![3-test_references_and_objects] Access the :class:`reflog ` easily. .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [4-test_references_and_objects] :end-before: # ![4-test_references_and_objects] Modifying References ******************** You can easily create and delete :class:`reference types ` or modify where they point to. .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [5-test_references_and_objects] :end-before: # ![5-test_references_and_objects] Create or delete :class:`tags ` the same way except you may not change them afterwards. .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [6-test_references_and_objects] :end-before: # ![6-test_references_and_objects] Change the :class:`symbolic reference ` to switch branches cheaply (without adjusting the index or the working tree). .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [7-test_references_and_objects] :end-before: # ![7-test_references_and_objects] Understanding Objects ********************* An Object is anything storable in git's object database. Objects contain information about their type, their uncompressed size as well as the actual data. Each object is uniquely identified by a binary SHA1 hash, being 20 bytes in size, or 40 bytes in hexadecimal notation. Git only knows 4 distinct object types being :class:`Blobs `, :class:`Trees `, :class:`Commits ` and :class:`Tags `. In GitPython, all objects can be accessed through their common base, can be compared and hashed. They are usually not instantiated directly, but through references or specialized repository functions. .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [8-test_references_and_objects] :end-before: # ![8-test_references_and_objects] Common fields are ... .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [9-test_references_and_objects] :end-before: # ![9-test_references_and_objects] :class:`Index objects ` are objects that can be put into git's index. These objects are trees, blobs and submodules which additionally know about their path in the file system as well as their mode. .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [10-test_references_and_objects] :end-before: # ![10-test_references_and_objects] Access :class:`blob ` data (or any object data) using streams. .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [11-test_references_and_objects] :end-before: # ![11-test_references_and_objects] The Commit object ***************** :class:`Commit ` objects contain information about a specific commit. Obtain commits using references as done in `Examining References`_ or as follows. Obtain commits at the specified revision .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [12-test_references_and_objects] :end-before: # ![12-test_references_and_objects] Iterate 50 commits, and if you need paging, you can specify a number of commits to skip. .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [13-test_references_and_objects] :end-before: # ![13-test_references_and_objects] A commit object carries all sorts of meta-data .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [14-test_references_and_objects] :end-before: # ![14-test_references_and_objects] Note: date time is represented in a ``seconds since epoch`` format. Conversion to human readable form can be accomplished with the various `time module `_ methods. .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [15-test_references_and_objects] :end-before: # ![15-test_references_and_objects] You can traverse a commit's ancestry by chaining calls to ``parents`` .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [16-test_references_and_objects] :end-before: # ![16-test_references_and_objects] The above corresponds to ``master^^^`` or ``master~3`` in git parlance. The Tree object *************** A :class:`tree ` records pointers to the contents of a directory. Let's say you want the root tree of the latest commit on the master branch .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [17-test_references_and_objects] :end-before: # ![17-test_references_and_objects] Once you have a tree, you can get its contents .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [18-test_references_and_objects] :end-before: # ![18-test_references_and_objects] It is useful to know that a tree behaves like a list with the ability to query entries by name .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [19-test_references_and_objects] :end-before: # ![19-test_references_and_objects] There is a convenience method that allows you to get a named sub-object from a tree with a syntax similar to how paths are written in a posix system .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [20-test_references_and_objects] :end-before: # ![20-test_references_and_objects] You can also get a commit's root tree directly from the repository .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [21-test_references_and_objects] :end-before: # ![21-test_references_and_objects] As trees allow direct access to their intermediate child entries only, use the traverse method to obtain an iterator to retrieve entries recursively .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [22-test_references_and_objects] :end-before: # ![22-test_references_and_objects] .. note:: If trees return Submodule objects, they will assume that they exist at the current head's commit. The tree it originated from may be rooted at another commit though, that it doesn't know. That is why the caller would have to set the submodule's owning or parent commit using the ``set_parent_commit(my_commit)`` method. The Index Object **************** The git index is the stage containing changes to be written with the next commit or where merges finally have to take place. You may freely access and manipulate this information using the :class:`IndexFile ` object. Modify the index with ease .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [23-test_references_and_objects] :end-before: # ![23-test_references_and_objects] Create new indices from other trees or as result of a merge. Write that result to a new index file for later inspection. .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [24-test_references_and_objects] :end-before: # ![24-test_references_and_objects] Handling Remotes **************** :class:`Remotes ` are used as alias for a foreign repository to ease pushing to and fetching from them .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [25-test_references_and_objects] :end-before: # ![25-test_references_and_objects] You can easily access configuration information for a remote by accessing options as if they were attributes. The modification of remote configuration is more explicit though. .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [26-test_references_and_objects] :end-before: # ![26-test_references_and_objects] You can also specify per-call custom environments using a new context manager on the Git command, e.g. for using a specific SSH key. The following example works with `git` starting at *v2.3*:: ssh_cmd = 'ssh -i id_deployment_key' with repo.git.custom_environment(GIT_SSH_COMMAND=ssh_cmd): repo.remotes.origin.fetch() This one sets a custom script to be executed in place of `ssh`, and can be used in `git` prior to *v2.3*:: ssh_executable = os.path.join(rw_dir, 'my_ssh_executable.sh') with repo.git.custom_environment(GIT_SSH=ssh_executable): repo.remotes.origin.fetch() Here's an example executable that can be used in place of the `ssh_executable` above: .. code-block:: shell #!/bin/sh ID_RSA=/var/lib/openshift/5562b947ecdd5ce939000038/app-deployments/id_rsa exec /usr/bin/ssh -o StrictHostKeyChecking=no -i $ID_RSA "$@" Please note that the script must be executable (i.e. `chmod +x script.sh`). `StrictHostKeyChecking=no` is used to avoid prompts asking to save the hosts key to `~/.ssh/known_hosts`, which happens in case you run this as daemon. You might also have a look at `Git.update_environment(...)` in case you want to setup a changed environment more permanently. Submodule Handling ****************** :class:`Submodules ` can be conveniently handled using the methods provided by GitPython, and as an added benefit, GitPython provides functionality which behave smarter and less error prone than its original c-git implementation, that is GitPython tries hard to keep your repository consistent when updating submodules recursively or adjusting the existing configuration. .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [1-test_submodules] :end-before: # ![1-test_submodules] In addition to the query functionality, you can move the submodule's repository to a different path <``move(...)``>, write its configuration <``config_writer().set_value(...).release()``>, update its working tree <``update(...)``>, and remove or add them <``remove(...)``, ``add(...)``>. If you obtained your submodule object by traversing a tree object which is not rooted at the head's commit, you have to inform the submodule about its actual commit to retrieve the data from by using the ``set_parent_commit(...)`` method. The special :class:`RootModule ` type allows you to treat your master repository as root of a hierarchy of submodules, which allows very convenient submodule handling. Its ``update(...)`` method is reimplemented to provide an advanced way of updating submodules as they change their values over time. The update method will track changes and make sure your working tree and submodule checkouts stay consistent, which is very useful in case submodules get deleted or added to name just two of the handled cases. Additionally, GitPython adds functionality to track a specific branch, instead of just a commit. Supported by customized update methods, you are able to automatically update submodules to the latest revision available in the remote repository, as well as to keep track of changes and movements of these submodules. To use it, set the name of the branch you want to track to the ``submodule.$name.branch`` option of the *.gitmodules* file, and use GitPython update methods on the resulting repository with the ``to_latest_revision`` parameter turned on. In the latter case, the sha of your submodule will be ignored, instead a local tracking branch will be updated to the respective remote branch automatically, provided there are no local changes. The resulting behaviour is much like the one of svn::externals, which can be useful in times. Obtaining Diff Information ************************** Diffs can generally be obtained by subclasses of :class:`Diffable ` as they provide the ``diff`` method. This operation yields a :class:`DiffIndex ` allowing you to easily access diff information about paths. Diffs can be made between the Index and Trees, Index and the working tree, trees and trees as well as trees and the working copy. If commits are involved, their tree will be used implicitly. .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [27-test_references_and_objects] :end-before: # ![27-test_references_and_objects] The item returned is a DiffIndex which is essentially a list of Diff objects. It provides additional filtering to ease finding what you might be looking for. .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [28-test_references_and_objects] :end-before: # ![28-test_references_and_objects] Use the diff framework if you want to implement git-status like functionality. * A diff between the index and the commit's tree your HEAD points to * use ``repo.index.diff(repo.head.commit)`` * A diff between the index and the working tree * use ``repo.index.diff(None)`` * A list of untracked files * use ``repo.untracked_files`` Switching Branches ****************** To switch between branches similar to ``git checkout``, you effectively need to point your HEAD symbolic reference to the new branch and reset your index and working copy to match. A simple manual way to do it is the following one .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [29-test_references_and_objects] :end-before: # ![29-test_references_and_objects] The previous approach would brutally overwrite the user's changes in the working copy and index though and is less sophisticated than a ``git-checkout``. The latter will generally prevent you from destroying your work. Use the safer approach as follows. .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [30-test_references_and_objects] :end-before: # ![30-test_references_and_objects] Initializing a repository ************************* In this example, we will initialize an empty repository, add an empty file to the index, and commit the change. .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: def test_add_file_and_commit :end-before: # ![test_add_file_and_commit] Please have a look at the individual methods as they usually support a vast amount of arguments to customize their behavior. Using git directly ****************** In case you are missing functionality as it has not been wrapped, you may conveniently use the :class:`git ` command directly. It is owned by each repository instance. .. literalinclude:: ../../test/test_docs.py :language: python :dedent: 8 :start-after: # [31-test_references_and_objects] :end-before: # ![31-test_references_and_objects] The return value will by default be a string of the standard output channel produced by the command. Keyword arguments translate to short and long keyword arguments on the command-line. The special notion ``git.command(flag=True)`` will create a flag without value like ``command --flag``. If ``None`` is found in the arguments, it will be dropped silently. Lists and tuples passed as arguments will be unpacked recursively to individual arguments. Objects are converted to strings using the ``str(...)`` function. Object Databases **************** :class:`git.Repo ` instances are powered by its object database instance which will be used when extracting any data, or when writing new objects. The type of the database determines certain performance characteristics, such as the quantity of objects that can be read per second, the resource usage when reading large data files, as well as the average memory footprint of your application. GitDB ===== The GitDB is a pure-python implementation of the git object database. It is the default database to use in GitPython 0.3. It uses less memory when handling huge files, but will be 2 to 5 times slower when extracting large quantities of small objects from densely packed repositories:: repo = Repo("path/to/repo", odbt=GitDB) GitCmdObjectDB ============== The git command database uses persistent git-cat-file instances to read repository information. These operate very fast under all conditions, but will consume additional memory for the process itself. When extracting large files, memory usage will be much higher than ``GitDB``:: repo = Repo("path/to/repo", odbt=GitCmdObjectDB) Git Command Debugging and Customization *************************************** Using environment variables, you can further adjust the behaviour of the git command. * **GIT_PYTHON_TRACE** * If set to non-0, all executed git commands will be shown as they happen * If set to *full*, the executed git command _and_ its entire output on stdout and stderr will be shown as they happen **NOTE**: All logging is outputted using a Python logger, so make sure your program is configured to show INFO-level messages. If this is not the case, try adding the following to your program:: import logging logging.basicConfig(level=logging.INFO) * **GIT_PYTHON_GIT_EXECUTABLE** * If set, it should contain the full path to the git executable, e.g. *c:\\Program Files (x86)\\Git\\bin\\git.exe* on windows or */usr/bin/git* on linux. And even more ... ***************** There is more functionality in there, like the ability to archive repositories, get stats and logs, blame, and probably a few other things that were not mentioned here. Check the unit tests for an in-depth introduction on how each function is supposed to be used. GitPython-3.1.37/git/000077500000000000000000000000001450324204500143145ustar00rootroot00000000000000GitPython-3.1.37/git/__init__.py000066400000000000000000000044771450324204500164410ustar00rootroot00000000000000# __init__.py # Copyright (C) 2008, 2009 Michael Trier (mtrier@gmail.com) and contributors # # This module is part of GitPython and is released under # the BSD License: https://opensource.org/license/bsd-3-clause/ # flake8: noqa # @PydevCodeAnalysisIgnore from git.exc import * # @NoMove @IgnorePep8 import inspect import os import sys import os.path as osp from typing import Optional from git.types import PathLike __version__ = "git" # { Initialization def _init_externals() -> None: """Initialize external projects by putting them into the path""" if __version__ == "git" and "PYOXIDIZER" not in os.environ: sys.path.insert(1, osp.join(osp.dirname(__file__), "ext", "gitdb")) try: import gitdb except ImportError as e: raise ImportError("'gitdb' could not be found in your PYTHONPATH") from e # END verify import # } END initialization ################# _init_externals() ################# # { Imports try: from git.config import GitConfigParser # @NoMove @IgnorePep8 from git.objects import * # @NoMove @IgnorePep8 from git.refs import * # @NoMove @IgnorePep8 from git.diff import * # @NoMove @IgnorePep8 from git.db import * # @NoMove @IgnorePep8 from git.cmd import Git # @NoMove @IgnorePep8 from git.repo import Repo # @NoMove @IgnorePep8 from git.remote import * # @NoMove @IgnorePep8 from git.index import * # @NoMove @IgnorePep8 from git.util import ( # @NoMove @IgnorePep8 LockFile, BlockingLockFile, Stats, Actor, rmtree, ) except GitError as _exc: raise ImportError("%s: %s" % (_exc.__class__.__name__, _exc)) from _exc # } END imports __all__ = [name for name, obj in locals().items() if not (name.startswith("_") or inspect.ismodule(obj))] # { Initialize git executable path GIT_OK = None def refresh(path: Optional[PathLike] = None) -> None: """Convenience method for setting the git executable path.""" global GIT_OK GIT_OK = False if not Git.refresh(path=path): return if not FetchInfo.refresh(): return # type: ignore [unreachable] GIT_OK = True # } END initialize git executable path ################# try: refresh() except Exception as _exc: raise ImportError("Failed to initialize: {0}".format(_exc)) from _exc ################# GitPython-3.1.37/git/cmd.py000066400000000000000000001514571450324204500154460ustar00rootroot00000000000000# cmd.py # Copyright (C) 2008, 2009 Michael Trier (mtrier@gmail.com) and contributors # # This module is part of GitPython and is released under # the BSD License: https://opensource.org/license/bsd-3-clause/ from __future__ import annotations import re import contextlib import io import logging import os import signal from subprocess import call, Popen, PIPE, DEVNULL import subprocess import threading from textwrap import dedent from git.compat import ( defenc, force_bytes, safe_decode, is_posix, is_win, ) from git.exc import CommandError from git.util import is_cygwin_git, cygpath, expand_path, remove_password_if_present, patch_env from .exc import GitCommandError, GitCommandNotFound, UnsafeOptionError, UnsafeProtocolError from .util import ( LazyMixin, stream_copy, ) # typing --------------------------------------------------------------------------- from typing import ( Any, AnyStr, BinaryIO, Callable, Dict, IO, Iterator, List, Mapping, Sequence, TYPE_CHECKING, TextIO, Tuple, Union, cast, overload, ) from git.types import PathLike, Literal, TBD if TYPE_CHECKING: from git.repo.base import Repo from git.diff import DiffIndex # --------------------------------------------------------------------------------- execute_kwargs = { "istream", "with_extended_output", "with_exceptions", "as_process", "stdout_as_string", "output_stream", "with_stdout", "kill_after_timeout", "universal_newlines", "shell", "env", "max_chunk_size", "strip_newline_in_stdout", } log = logging.getLogger(__name__) log.addHandler(logging.NullHandler()) __all__ = ("Git",) # ============================================================================== ## @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[subprocess.Popen, "Git.AutoInterrupt"]], None]] = None, decode_streams: bool = True, kill_after_timeout: Union[None, float] = None, ) -> None: """Registers for notifications to learn that process output is ready to read, and dispatches lines to the respective line handlers. This function returns once the finalizer returns :return: result of finalizer :param process: 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. Set it to False if `universal_newline == True` (then streams are in text-mode) or if decoding must happen later (i.e. for Diffs). :param kill_after_timeout: 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: log.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 if finalizer: return finalizer(process) else: return None 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 -- @} # value of Windows process creation flag taken from MSDN CREATE_NO_WINDOW = 0x08000000 ## CREATE_NEW_PROCESS_GROUP is needed to allow killing it afterwards, # see https://docs.python.org/3/library/subprocess.html#subprocess.Popen.send_signal PROC_CREATIONFLAGS = ( CREATE_NO_WINDOW | subprocess.CREATE_NEW_PROCESS_GROUP if is_win else 0 # type: ignore[attr-defined] ) # mypy error if not windows class Git(LazyMixin): """ 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 GIT_PYTHON_TRACE environment variable 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", "_git_options", "_persistent_git_options", "_environment", ) _excluded_ = ("cat_file_all", "cat_file_header", "_version_info") re_unsafe_protocol = re.compile("(.+)::.+") 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 that should work on linux and windows # Enables debugging of GitPython's git commands GIT_PYTHON_TRACE = os.environ.get("GIT_PYTHON_TRACE", False) # If True, a shell will be used when executing git commands. # This should only be desirable on Windows, see https://github.com/gitpython-developers/GitPython/pull/126 # and check `git/test_repo.py:TestRepo.test_untracked_files()` TC for an example where it is required. # Override this value using `Git.USE_SHELL = True` USE_SHELL = False # Provide the full path to the git executable. Otherwise it assumes git is in the path _git_exec_env_var = "GIT_PYTHON_GIT_EXECUTABLE" _refresh_env_var = "GIT_PYTHON_REFRESH" GIT_PYTHON_GIT_EXECUTABLE = None # note that the git executable is actually found during the refresh step in # the top level __init__ @classmethod def refresh(cls, path: Union[None, PathLike] = None) -> bool: """This gets called by the refresh function (see the top level __init__). """ # 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 cls.GIT_PYTHON_GIT_EXECUTABLE = new_git # test if the new git executable path is valid # - a GitCommandNotFound error is spawned by ourselves # - a PermissionError is spawned if the git executable provided # 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() """ ) % cls._git_exec_env_var ) # revert to whatever the old_git was cls.GIT_PYTHON_GIT_EXECUTABLE = old_git 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 # 1|w|warn|warning # 2|r|raise|e|error mode = os.environ.get(cls._refresh_env_var, "raise").lower() quiet = ["quiet", "q", "silence", "s", "none", "n", "0"] warn = ["warn", "w", "warning", "1"] error = ["error", "e", "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 warning can be silenced or aggravated in the future by setting the $%s environment variable. Use one of the following values: - %s: for no warning or exception - %s: for a printed warning - %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: print("WARNING: %s" % 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 warning or exception - %s: for a printed warning - %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 init refresh and the refresh mode # was not error, go ahead and set the GIT_PYTHON_GIT_EXECUTABLE # such that we discern the difference between a first import # and a second import 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("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: if is_cygwin is None: is_cygwin = cls.is_cygwin() if is_cygwin: url = cygpath(url) else: """Remove any backslahes from urls to be written in config files. Windows might create config-files containing paths with backslashed, but git stops liking them as it will escape the backslashes. Hence we undo the escaping just to be sure. """ 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 `::
`, 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 ` can be used to execute arbitrary commands, this are blocked by default. """ # Options can be of the form `foo` or `--foo bar` `--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(object): """Kill/Interrupt the stored process instance once this instance goes out of scope. It is used to prevent processes piling up in case iterators stop reading. Besides all attributes are wired through to the contained process object. The wait method was 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 None except OSError as ex: log.info("Ignored error after process had died: %r", ex) # can be that nothing really exists anymore ... if os is None or getattr(os, "kill", None) is None: return None # try to kill it try: proc.terminate() status = proc.wait() # ensure process goes away self.status = self._status_code_if_terminate or status except OSError as ex: log.info("Ignored error after process had died: %r", ex) except AttributeError: # try windows # for some reason, providing None for stdout/stderr still prints something. This is why # we simply use the shell and redirect to nul. Its slower than CreateProcess, question # is whether we really want to see all these messages. Its annoying no matter what. if is_win: call( ("TASKKILL /F /T /PID %s 2>nul 1>nul" % str(proc.pid)), shell=True, ) # 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 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) log.debug("AutoInterrupt wait stderr: %r" % (errstr,)) raise GitCommandError(remove_password_if_present(self.args), status, errstr) return status # END auto interrupt class CatFileContentStream(object): """Object representing a sized read-only stream returning the contents of an object. It 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 is read to the end of the objects's lifetime, we read the rest to assure the underlying stream continues to work""" __slots__: Tuple[str, ...] = ("_stream", "_nbr", "_size") def __init__(self, size: int, stream: IO[bytes]) -> None: self._stream = stream self._size = size self._nbr = 0 # num 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: # assure we don't try to read past our limit size = min(bytes_left, size) else: # they try to read all, make sure its 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 # includes terminating newline self._stream.read(bytes_left + 1) # END handle incomplete read def __init__(self, working_dir: Union[None, PathLike] = 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 os.getcwd(). It is meant to be the working tree directory if available, or the .git directory in case of bare repositories.""" super(Git, self).__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 command slots self.cat_file_header: Union[None, TBD] = None self.cat_file_all: Union[None, TBD] = None 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 _call_process with your arguments.""" if name[0] == "_": return LazyMixin.__getattr__(self, 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: is a dict of keyword arguments. these arguments are passed as in _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) def _set_cache_(self, attr: str) -> None: if attr == "_version_info": # We only use the first 4 numbers, as everything else could be strings in fact (on windows) process_version = self._call_process("version") # should be as default *args and **kwargs used version_numbers = process_version.split(" ")[2] self._version_info = cast( Tuple[int, int, int, int], tuple(int(n) for n in version_numbers.split(".")[:4] if n.isdigit()), ) else: super(Git, self)._set_cache_(attr) # END handle version info @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, int, int, int]: """ :return: tuple(int, int, int, int) tuple with integers representing the major, minor and additional version numbers as parsed from git version. This value is generated on demand and is cached""" 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]: """Handles executing the command on the shell and consumes and returns the returned information (stdout) :param command: The command argument list to execute. It should be a string, or a sequence of program arguments. The program to execute is the first item in the args sequence or string. :param istream: Standard input filehandle passed to 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 himself. It is important to note that the process will be placed into an 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 output to the given stream directly. This feature only has any effect if as_process is False. Processes will always be created with a pipe due to issues with subprocess. This merely is a workaround as data will be copied from the output pipe to the given output stream directly. Judging from the implementation, you shouldn't use this flag ! :param stdout_as_string: if False, the commands 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 env: A dictionary of environment variables to be passed to `subprocess.Popen`. :param max_chunk_size: Maximum number of bytes in one chunk of data passed to the output_stream in one invocation of write() method. If the given number is not positive then the default value is used. :param subprocess_kwargs: Keyword arguments to be passed to 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. :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 `Popen(..., shell=True)`). It overrides :attr:`USE_SHELL` if it is not `None`. :param kill_after_timeout: To specify 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. This feature is not supported on Windows. It's also worth noting that kill_after_timeout uses SIGKILL, which can have negative side effects on a repository. For example, stale locks in case of git gc could render the repository incapable of accepting changes until the lock is manually removed. :param strip_newline_in_stdout: Whether to strip the trailing ``\\n`` of the command stdout. :return: * str(output) if extended_output = False (Default) * tuple(int(status), str(stdout), str(stderr)) if extended_output = True if output_stream is True, the stdout value will be your output stream: * output_stream if extended_output = False * tuple(int(status), output_stream, str(stderr)) if extended_output = True Note git is executed with LC_MESSAGES="C" to ensure consistent output regardless of system language. :raise GitCommandError: :note: If you add additional keyword arguments to the signature of this method, you must update the execute_kwargs tuple 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): log.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 stackoverflow (http://goo.gl/l74GC8), 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 is_win: cmd_not_found_exception = OSError if kill_after_timeout is not None: raise GitCommandError( redacted_command, '"kill_after_timeout" feature is not supported on Windows.', ) # Only search PATH, not CWD. This must be in the *caller* environment. The "1" can be any value. maybe_patch_caller_env = patch_env("NoDefaultCurrentDirectoryInExePath", "1") else: cmd_not_found_exception = FileNotFoundError # NOQA # exists, flake8 unknown @UndefinedVariable maybe_patch_caller_env = contextlib.nullcontext() # end handle stdout_sink = PIPE if with_stdout else getattr(subprocess, "DEVNULL", None) or open(os.devnull, "wb") istream_ok = "None" if istream: istream_ok = "" log.debug( "Popen(%s, cwd=%s, universal_newlines=%s, shell=%s, istream=%s)", redacted_command, cwd, universal_newlines, shell, istream_ok, ) try: with maybe_patch_caller_env: proc = Popen( command, env=env, cwd=cwd, bufsize=-1, stdin=istream or DEVNULL, stderr=PIPE, stdout=stdout_sink, shell=shell is not None and shell or self.USE_SHELL, close_fds=is_posix, # unsupported on windows universal_newlines=universal_newlines, creationflags=PROC_CREATIONFLAGS, **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) def _kill_process(pid: int) -> None: """Callback method to kill a process.""" p = Popen( ["ps", "--ppid", str(pid)], stdout=PIPE, creationflags=PROC_CREATIONFLAGS, ) 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: # Windows does not have SIGKILL, so use SIGTERM instead sig = getattr(signal, "SIGKILL", signal.SIGTERM) os.kill(pid, sig) for child_pid in child_pids: try: os.kill(child_pid, sig) except OSError: pass kill_check.set() # tell the main routine that the process was killed 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 # end if kill_after_timeout is not None: kill_check = threading.Event() watchdog = threading.Timer(kill_after_timeout, _kill_process, args=(proc.pid,)) # 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: if kill_after_timeout is not None: watchdog.start() stdout_value, stderr_value = proc.communicate() if kill_after_timeout is not None: watchdog.cancel() if kill_check.is_set(): stderr_value = 'Timeout: the command "%s" did not complete in %d ' "secs." % ( " ".join(redacted_command), kill_after_timeout, ) if not universal_newlines: stderr_value = stderr_value.encode(defenc) # strip trailing "\n" if stdout_value.endswith(newline) and strip_newline_in_stdout: # type: ignore stdout_value = stdout_value[:-1] if stderr_value.endswith(newline): # type: ignore 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 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 "" # end if stderr_value: log.info( "%s -> %d; stdout: '%s'; stderr: '%s'", cmdstr, status, as_text(stdout_value), safe_decode(stderr_value), ) elif stdout_value: log.info("%s -> %d; stdout: '%s'", cmdstr, status, as_text(stdout_value)) else: log.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 ``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 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]: """Transforms 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: is a dict of keyword arguments. these arguments are passed as in _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 given, execute called 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: is the command. Contained "_" characters will be converted to dashes, such as in 'ls_files' to call 'ls-files'. :param args: is 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: It contains key-values for the following: - the :meth:`execute()` kwds, as listed in :var:`execute_kwargs`; - "command options" to be converted by :meth:`transform_kwargs()`; - the `'insert_kwargs_after'` key which its value must match one of ``*args`` and any cmd-options will 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 ``execute`` if no args given used execute default (esp. as_process = False, stdout_as_string = True) and return 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: 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: raise ValueError("SHA could not be resolved, git returned: %r" % (header_line.strip())) 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]: """As 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"]: """As get_object_header, 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 Command 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 GitPython-3.1.37/git/compat.py000066400000000000000000000043121450324204500161510ustar00rootroot00000000000000# -*- coding: utf-8 -*- # config.py # Copyright (C) 2008, 2009 Michael Trier (mtrier@gmail.com) and contributors # # This module is part of GitPython and is released under # the BSD License: https://opensource.org/license/bsd-3-clause/ """utilities to help provide compatibility with python 3""" # flake8: noqa import locale import os import sys from gitdb.utils.encoding import ( force_bytes, # @UnusedImport force_text, # @UnusedImport ) # typing -------------------------------------------------------------------- from typing import ( Any, AnyStr, Dict, IO, Optional, Tuple, Type, Union, overload, ) # --------------------------------------------------------------------------- is_win: bool = os.name == "nt" is_posix = os.name == "posix" is_darwin = os.name == "darwin" defenc = sys.getfilesystemencoding() @overload def safe_decode(s: None) -> None: ... @overload def safe_decode(s: AnyStr) -> str: ... def safe_decode(s: Union[AnyStr, None]) -> Optional[str]: """Safely decodes 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 encodes 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 unicodes 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 GitPython-3.1.37/git/config.py000066400000000000000000001033331450324204500161360ustar00rootroot00000000000000# config.py # Copyright (C) 2008, 2009 Michael Trier (mtrier@gmail.com) and contributors # # This module is part of GitPython and is released under # the BSD License: https://opensource.org/license/bsd-3-clause/ """Module containing module parser implementation able to properly read and write configuration files""" import sys import abc from functools import wraps import inspect from io import BufferedReader, IOBase import logging import os import re import fnmatch from git.compat import ( defenc, force_text, is_win, ) from git.util import LockFile import os.path as osp import configparser as cp # 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 git.repo.base import Repo from io import BytesIO 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 py 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] # ------------------------------------------------------------- __all__ = ("GitConfigParser", "SectionConstraint") log = logging.getLogger("git.config") log.addHandler(logging.NullHandler()) # invariants # represents the configuration level of a configuration file CONFIG_LEVELS: ConfigLevels_Tup = ("system", "user", "global", "repository") # Section pattern to detect conditional includes. # https://git-scm.com/docs/git-config#_conditional_includes CONDITIONAL_INCLUDE_REGEXP = re.compile(r"(?<=includeIf )\"(gitdir|gitdir/i|onbranch):(.+)\"") 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 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(MetaParserBuilder, cls).__new__(cls, name, bases, clsdict) return new_type def needs_values(func: Callable[..., _T]) -> Callable[..., _T]: """Returns method assuring 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 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(SectionConstraint, self).__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 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(_OMD, self).__setitem__(key, [value]) def add(self, key: str, value: Any) -> None: if key not in self: super(_OMD, self).__setitem__(key, [value]) return None super(_OMD, self).__getitem__(key).append(value) def setall(self, key: str, values: List[_T]) -> None: super(_OMD, self).__setitem__(key, values) def __getitem__(self, key: str) -> Any: return super(_OMD, self).__getitem__(key)[-1] def getlast(self, key: str) -> Any: return super(_OMD, self).__getitem__(key)[-1] def setlast(self, key: str, value: Any) -> None: if key not in self: super(_OMD, self).__setitem__(key, [value]) return prior = super(_OMD, self).__getitem__(key) prior[-1] = value def get(self, key: str, default: Union[_T, None] = None) -> Union[_T, None]: return super(_OMD, self).get(key, [default])[-1] def getall(self, key: str) -> List[_T]: return super(_OMD, self).__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 is_win 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 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 git.config 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. If used as a context manager, will release the locked file.""" # { Configuration # The lock type determines the type of lock to use in new configuration readers. # They must be compatible to the LockFile interface. # A suitable alternative would be the BlockingLockFile t_lock = LockFile re_comment = re.compile(r"^\s*[#;]") # } END configuration optvalueonly_source = r"\s*(?P