Saravanan666/pypi-org huggingface dataset:
Package: git-project
The extensible stupid project managerSetuppip installgit-projectDescriptiongit-project is a git extension to manage development of a project hosted in a
git repository.  By itself git-project does almost nothing.  Its functionality
is enhanced by plugins.git-project-core-pluginsprovides a set of
basic functionality and should almost always be installed alongside git-project.ConventionsSymlinks identiy projects to thegit-projectcommand.  For example, ifgit-fizzbinis symlinked togit-project, thengit fizzbin <command>will invokegit-projectwithfizzbinas the “active project.”  To
emphasize this, we show git-project commands with a generic<project>identifier:git <project> --helpDiscussionWith git-project and its core plugins you can:Initialize a development environment at clone time (or after clone time)Manage branchesManage worktreesSet and invoke commandsgit-project is intended to make switching between active ‘tasks’ in a repository
simple and fast, without losing the progress context of existing tasks.  For
example the core plugins set up build environments such that switching among
projects and worktrees does not result in “rebuilding the world.”  Builds can be
configured to invoke complex commands via a convenient name (e.g.git <project> build debug)Substitution variablesCommands that allow substitution take a form{varname}in their configured
textual representation and substitute it with the value ofvarname.varnamecan be any configured value under<project>, for example:[project]
    myvar = valuegit-projecthas several built-in substitution variables that various
commands and plugins can use:branchThe name of the currently checked-out branchgitdirThe value ofGITDIRgit_common_dirThe value ofGIT_COMMON_DIRprojectThe value of<project>
Package: git-project-status
git_project_statusReal simple, just iterates through the first-level subdirectories and does the equivalent of git status, only uglier.If you want more logs, set an environment variable ofLOGURU_LOG_LEVEL=DEBUG.Installation:pip install git-project-statusWhich will create a console scriptgit_project_status.Changelog0.0.6 - Fixed handling detached heads.0.0.7 - 2022-01-08 - Updated build tooling, broke the script name. Whoops! Pulled.0.0.8 - 2022-01-08 - Fixed the script name. Whoops! Pulled.0.0.9 - 2022-01-08 - Fixed the script config.0.0.10 - 2022-01-08 - Added the option to specify a directory.0.0.11 - 2022-01-08 - Cleaned up some formatting, using pathlib for checking.0.0.12 - 2022-06-02 - Shaved the yak, moved packaging tools, added more type-checking.
Package: git-props
Git propertiesA simple Python package to determine some properties from a git
repository.System requirementsPython:Python 3.6 or newer.Required library packages:setuptoolspackagingExternal Programs:gitOptional library packages:git-propsThis package is used to extract some metadata such as the version
number out of git, the version control system.  All releases embed
that metadata in the distribution.  So this package is only needed
to build out of the plain development source tree as cloned from
GitHub, but not to build a release distribution.pytest>= 3.0Only needed to run the test suite.distutils-pytestOnly needed to run the test suite.PyYAML>= 5.1Only needed to run the test suite.Copyright and LicenseCopyright 2023–2024 Rolf KrahlLicensed under theApache License, Version 2.0 (the “License”); you
may not use this package except in compliance with the License.Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an “AS IS” BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied.  See the License for the specific language governing
permissions and limitations under the License.
Package: gitprovenance
Keep track of git repository commits, which correspond to figures generated via
matplotlib.  This is a pedestrian approach, for cases where a full provenance
tracking system is overkill.UsageUsegitprovance.savefiginstead ofplt.savefig:>>> import matplotlib.pyplot as plt, gitprovenance
>>> plt.plot([1,2,3,4])
>>> gitprovenance.savefig("foo.pdf")This adds a commit to a hidden branch in the current git repository,
which contains the current state of the tree:$ git log refs/provenance/main
def11c6 (refs/provenance/main) Provenance commit
cd66bed (HEAD -> master, origin/master, origin/HEAD) Add filesThe saved figure contains an embedded stamp that refers to the provenance
commit, and the head of the current branch at the time, plus a diff
between the provenance commit and the branch head:$ grep PROVENANCE-STAMP foo.pdf
%% @@PROVENANCE-STAMP:commit:def11c6410e78925eaef7feceaadf07fffcbc4f8:head:cd66beda90ddb285d7140cabb4a2a4e504980897:diff:diff --git a/gitprovenance.py b/gitprovenance.py
%% index 011c5f8..a566740 100644
%% --- a/gitprovenance.py
%% +++ b/gitprovenance.py
...
Package: git-prune
git-pruneClean up your local git branches to match the remote with one command. This tool checks your remote location for current branches, compares this list against the local git branches, and gives you the option to remove all orphaned local branches.Installationpip3 install git-pruneUsagegit-prune-- Prunes local branches in the current working directory.git-prune -d /Path/to/repository-- Prunes local branches in the provided directory.
Package: gitpub
## Github library to interact with it's public APIRequirements:<br>------------------* [pytest](http://doc.pytest.org/en/latest/): Uses __pytest__ as the unit-testing framework. Install using <code>pip install pytest</code>.* [requests](https://pypi.python.org/pypi/requests/2.11.1): Uses __requests__ for interacting with the various api urls.How to use:<br>--------------* __Load Github Profile & Public Repo details of a user__: Loading a github profile just needs a _username_ to startwith. Here is a small demo with _username_ [__demfier__](https://github.com/Demfier).<br>Type the following commands in python shell:```pythonimport gitpubusername = 'demfier'profile = gitpub.Profile()profile.load_gh_profile(username)  # loads profile details of `username`profile.get_public_repos()  # loads all the public repo details of `username````* __Run Tests__: Just run the command<code>py.test -v</code> to see the test results.
Package: gitpulse
GitPulseGitPulse is a Python-based command-line tool that generates an HTML report summarizing Git log data for a software development project. It provides insights into the number of commits and merges for each developer who has contributed to the project.InstallationTo install GitPulse, you can use pip. Open a terminal window and enter the following command in adminstrator mode:pip install gitpulseUsageGitPulse can be run from the command line using thegitpulsecommand in the the Git repository.Here is the basic syntax for using GitPulse:gitpulseOn success there will be clean exit to console. The generated report will be saved in the current directory with namegitpulse_report.html.BenefitsThe following are some benefits of using GitPulse:Quick and easy analysis: GitPulse provides a quick and easy way to analyze Git logs data and gain insights into the number of commits and merges for each developer who has contributed to the project. This can help project managers and developers to identify trends, patterns, and areas for improvement.Customizable report: GitPulse generates an HTML report that can be customized to meet the specific needs of the project. Developers can modify the report template to include additional data points or to change the report format as needed.Saves time and effort: GitPulse saves time and effort by automating the process of analyzing Git logs data. Rather than manually analyzing the logs, developers can use GitPulse to generate a report quickly and easily.Integrating with CI/CD PipelineIntegrating GitPulse into the CI/CD pipeline can provide valuable insights into the development process and help identify areas for improvement. By running GitPulse as part of the pipeline, developers can continuously monitor the activity of their team members and track changes in the development process over time. This can help to identify potential issues early on and make timely adjustments as needed.Data-Driven Decision-MakingGitPulse provides objective data on the activity of individual developers, which can help to inform decisions related to knowledge retention and team composition. By using the reports generated by GitPulse, team members can better understand each other's strengths and weaknesses and work together more effectively.ContributingContributions to GitPulse are always welcome! If you find a bug or have an idea for a new feature, please open an issue on the GitHub repository. If you would like to contribute code, please fork the repository and submit a pull request.LicenseThis project is licensed under the MIT License - see the LICENSE file for details.
Package: git-pusher
python-git-pusherPush files to multiple repos in one goExplore the docs »Report Bug·Request FeatureTable of ContentsTable of ContentsAbout The ProjectBuilt WithGetting StartedPrerequisitesInstallationUsageExample ConfigRoadmapContributingLicenseContactAcknowledgementsAbout The ProjectThis project is created out of neccessity to push multiple files into multiple git repos at once.
For example push a LICENSE or ISSUE TEMPLATE or Update a Github Action. This project is not limited to this.Built WithPythonGITPoetryGetting StartedPrerequisitesInstall Python 3.6 or higherInstallationInstall the tool viapip3 install git-pusherUsageCreate a config yaml with all the repos and the files ( relative or absulute paths )Run the commandgit-pusher --config ./config.yaml --branch branch-nameExample Configrepos:-git@github.com:stiliajohny/test1.git-git@github.com:stiliajohny/test2.git-git@github.com:stiliajohny/test3.gitfiles:-./LICENSE.md-./README.md-./CHANGELOG.md-./CONTRIBUTING.md-./CODE_OF_CONDUCT.md-./CONFIG.mdRoadmapSee theopen issuesfor a list of proposed features (and known issues).ContributingContributions are what make the open source community such an amazing place to be learn, inspire, and create. Any contributions you make aregreatly appreciated.Fork the ProjectCreate your Feature Branch (git checkout -b feature/AmazingFeature)Commit your Changes (git commit -m 'Add some AmazingFeature')Push to the Branch (git push origin feature/AmazingFeature)Open a Pull RequestLicenseDistributed under the GPLv3 License. SeeLICENSEfor more information.ContactJohn Stilia -stilia.johny@gmail.comAcknowledgementsGitHub Emoji Cheat SheetImg ShieldsChoose an Open Source LicenseGitHub Pages
Package: gitpylib
[![PyPI version](https://badge.fury.io/py/gitpylib.svg)](http://badge.fury.io/py/gitpylib)Python library for Git.gitpylib is a lightweight wrapper of thegitcommand.As of 02/2015 gitpylib has been phased out and merged into
[Gitless](https://github.com/sdg-mit/gitless “Gitless”).InstallViapip(the Python Package Manager):$> pip install gitless
Package: gitpyman
# gitpyman
Manager your github : add comment for your response, stars, following use local language.
With the growth of stars and follwing, sometimes it’s easy to forget why you care about them.### Interface![image.png](https://i.loli.net/2019/07/23/5d3688f11811917513.png)### Use
- method 1: if you is a pythoner, you can :`python # you can clone repo and use `python setup.py install` # or #`pip install gitpyman` # after, use command `gitpyman` in console. `method 2: or download from :
…### User Guide![image.png](https://i.loli.net/2019/07/23/5d3685331e93078582.png)
(In this page , after you write website, username, password , clickLogin/Updatebutton, will auto write to web ,so you can skip step 1.)
1. First Time , need logingithub.com(after will cache, No more login required)
1. Everytime run software, must be clickLogin/Updatebutton for get User authentication.
1.double clickcan open url to reop;![image.png](https://i.loli.net/2019/07/23/5d3686270f75f26396.png)
1. filter keywords(user The blank space split)![image.png](https://i.loli.net/2019/07/23/5d3686b06295016538.png)### How to Contribute1. clone repo;
1. in pycharm setgitpymanfolder asSources Root;
1. inClient.pysetDEBUG = True(about line 65);### TODO:
- write tests(Sorry, I don’t konw how to write unittest);
- support pyside2;
- add UML file;
- add doc;
- (add hook star/watch);
- add release;
- add backup .db –can’t upload github,because has pwd;
- (add Multiple page);
- change .db path –bug;
Package: git-python-utils
Install from pypi:python -m pip install git_python_utilsgit_python_tools.version_stringAutomatic version string generation based on git history. Customizable version string
format using a format string or a template file.Run with -h for usage information:python -m git_python_utils.version_string -hgit_python_tools.author_statsPrints information about each author in the git history (number of commits,
number of lines, latest commit).Run with -h for usage information:python -m git_python_utils.author_stats -hgit_python_tools.changelogPrints a CHANGELOG style list of commits between a particular range, grouped
by commit date. By default, will include commits between the most recent tag and
HEAD.Run with -h for usage information:python -m git_python_utils.changelog -h
Package: git-qdiff
git-qdiff (v0.2.2)==================So you miss `bzr qdiff` ?-------------------------Of course you do ! Why would you be here ?Installation------------$ sudo pip install --upgrade git-qdiffDependencies------------- git (1.7.11+)- bazaar- qbzr tools- rsyncUsage-----Once installed, you should be able to use this command from any git repository:$ git qdiffAnd this should launch your favorite difftool:![screenshot](https://github.com/amigrave/git-qdiff/raw/master/screenshot.png)Of course you can use the same notation as you would with `git diff`:```bash# Show both staged and unstaged changes$ git qdiff HEAD# Using tilde and carrets$ git qdiff HEAD~2..HEAD~3# Between commits$ git qdiff 53c43de..7c70faf# Before merging branches$ git qdiff origin/master...my_feature_branch# ...```Known problem-------------- `Refresh` button won't workBefore reporting an issue, please check that your `bzr qdiff` tool works welland that you can actually commit something with bazaar.Goodies-------### tigFor those using [tig](http://jonas.nitro.dk/tig/), here's a handy shortcut bound to `D` key.Add this to your `.gitconfig`:```ini[tig "bind"]generic = D !git qdiff %(commit)~1..%(commit)```*Note: Don't try this on the "unstaged changes" line in tig's log view*### aliasThis alias is handy when you want to show a single commit in `git-qdiff`.Add this to your `.gitconfig`:```ini[alias]qshow = "!git show $1 --quiet; git qdiff $1~1...$1"```and use it like this:$ git qshow 61376d9License-------This software is licensed under the MIT license
Package: gitql
Gitql is a Git query language.Gitql is written in Golang bycloudsonoriginally, I
reimplemented by python language, and with some enhancements.Installationpip install gitqlorpip install git+https://github.com/mackong/gitql.git#egg=gitqlorpython setup.py installUsageusage: gitql [-h] [-i] [-p PATH] [-s] [-t {table,json}] [-f] [-v] [SQL]

Git query language

positional arguments:
  SQL                   A query to run

optional arguments:
  -h, --help            show this help message and exit
  -i, --interactive     Enter to interactive mode
  -p PATH, --path PATH  The path to run gitql (default ".")
  -s, --show-tables     Show all tables
  -t {table,json}, --type {table,json}
                        The output type format (default "table")
  -f, --format-json     Format the json output
  -v, --version         Show the version of gitqlCompare toGitqltables, fields, keywordscase-insensitiveSelect * From COMMITS wherE author='bob';field message -> summary, full_message -> message changed in commits
table* can combined with other fieldsselect *, name, full_name from tags;a table footer added similar tomysqlkeywordNOTaddedselect * from tags where not 'RC' in name;limit -1 forallrecordsselect * from tags limit -1;offset added to limitselect * from tags limit 5, 5;orselect * from tags limit 5 offset 5;tailing;is optionalselect * from tagsorselect * from tags;value type limitation in where clause removedselect summary, date from commits where '2016-12-28' < date;orselect * from commits where 1 and 2;
Package: git-query
A Git plugin to look up stuff like pending reviews, review URLs, etc
from GerritSetupsudo pip installgit-queryConfigurationAdd the following lines to your .bash_profile:export GERRIT_HOST='http://gerrit.example.com'
export GERRIT_USERNAME='your_username'
export GERRIT_TOKEN='your_api_token'  # explained belowDon’t forget to source (or reset your terminal session)!Generating a Gerrit API TokenGo to your Settings in Gerrit (in the menu when you click on your
name in the top-right)ClickHTTP PasswordClickGenerate PasswordUsageYou can either usegit queryorgit ?. You will need to be in a
repo that exists in Gerrit.# get info from Gerrit about the current commit
git query
git ?

# list all Gerrit IDs for the current repo
git query -a
git query --all
git ? -a
git ? --all

# get info from Gerrit about a specific ID
git query 1234
git ? 1234
Package: gitrack
giTrackZero-touch time tracking using GitBackgroundgiTrack is an utility that aims to make developer's life simpler by taking out the frequent management's requirement of
reporting the time spent. It does so using Git's commit messages and times for creating time entries, which to my
experience correlates quiet a lot. It won't produce 100% accurate reports, but it should be "good enough" to meet the
requirement (and it will at least motivate the developer to write proper commit's messages).ProvidersgiTracks has notion of providers which are the backends where the time entries are stored. Current providers:TogglFeel free to open an issue with a request for new providers! Anything that has an API should be possible to plug-in.InstallEasiest way to install this package is through PyPi:$pipinstallgitrackIt is also possible to usepexbuild which leaves out the hassle aroundpip(virtualenvs etc.).
You can download the build fromlatest releaseeither manually or using
small installer script:$curlhttps://raw.githubusercontent.com/AuHau/gitrack/master/bin/install.sh|bashUsageFor full overview of giTrack's capabilities please seefull documentation.# Initialize Git repo for giTrack's usage$gitrackinit# Start giTrack's tracking$gitrackstart# If you want to see the status of giTrack in your shell$gitrackprompt# Do your work and commit it, giTrack will pick it up# At the end of your work stop giTrack's tracking$gitrackstopContributingFeel free to dive in, contributions are welcomed!Open an issueor submit PRs.For PRs and tips about development please seecontribution guideline.LicenseMIT ©  Adam Uhlir
Package: gitrange
GitRangeGit is confusing. Most of us know the basics, but we all have to Google for
specific incantations from time to time. If you haven't used a different VCS,
like Mercurial, then you may not realize that this Googling for these somewhat
common things isn't normal or necessary--that it's a consequence of Git's
inconsistent UI.GitRange (gr) attempts to bring some of that consistency to git by providing
a common syntax for specifying git commit ranges and passing those ranges to a
git subcommand.UsageUSAGE: gr <selector> [<git-command>] [<git-command-args>]

  Invoke a git command with a more sane range-selection syntax.

SELECTORS

  -b, --branch <commit-id>  A range of commits from <commit-id> to the common
                            ancestor of <commit-id> and `master`.

  -c, --commit <commit-id>  Exactly the commit identified by <commit-id>.

COMMIT ID SYNTAX

  `.`, `0`                  The current commit.

  <branch-name>             The name of the git branch. Resolves to the
                            branch's tip.

  <commit-sha>              A git commit sha.

  <tag>                     A git tag.

  (nonpositive integers)    A relative number of parent commits from `.`.
                            Positive integers are an error.

OTHER ARGUMENTS

  git-command               The git command to invoke with the range resulting
                            from the provided selector. If this is missing, the
                            range will be printed directly (useful for
                            debugging). This should not include the "git"
                            (e.g., "log", not "git log").

  git-command-args          The arguments to the git command. These will be
                            passed to <git-command> before the range.

EXAMPLES

  Log all changes in a branch:

    $ gr -b my-feature-branch log

  Log all changes in the current branch

    $ gr -b . log

  Diff a single changeset (against its parent):

    $ gr -c <git-sha1> diff

  Diff the current changeset (against its parent):

    $ gr -c . diff

  Diff an entire branch

    $ gr -b my-feature-branch diff

  Diff the current branch up to the parent commit

    $ gr -b -1 diff
    diff --git a/bar b/bar
    new file mode 100644
    index 0000000000..e69de29bb2
    diff --git a/foo b/foo
    new file mode 100644
    index 0000000000..e69de29bb2

  Pass other arguments

    $ gr -b . log --oneline --graph --decorate
    * dd6e2ccff4 (HEAD -> my-feature-branch) Removed foo and bar
    * 357bc24de5 Added bar
    * 8dd48a84d0 Added foo

  Debug a range

    $ gr -c .
    HEAD~1..HEADContributingAll pull requests must pass theCI checks. These
includemypy --strictandblack --checkfor all Python files. Further, this
README.md is generated bygen/mkreadme.py. Instead of
editing it directly, editgen/README.md(the template file
used to generate it).
Package: gitrc
gitrcA simple command line utility to write all repos from Github for a given user
or organization to standard output.  Github credentials are optional.  But,
providingusernameandpasswordincreases the number of repos you can
download at one time due to Github's rate limiting policy.  To usegitrcin
shell scripts thepasswordcan be passed via standard input, for better
security practices.InstallationpipinstallgitrcUsage$gitrcdownload-h
usage:gitrcdownload[-h][--usernameUSERNAME][--passwordPASSWORD][-p][--password_promptPASSWORD_PROMPT][--urlURL]github_username

positionalarguments:github_usernameDownloadallreposforthisGithubuseraccount.

optionalarguments:-h,--helpshowthishelpmessageandexit--usernameUSERNAMEGithubusernametoauthenticatewith.--passwordPASSWORDGithubpasswordtoauthenticatewith.-pIfsetyouwillbepromptedforapassword.--password_promptPASSWORD_PROMPT--urlURLTheURLfortheGithbAPIendpoint.
Package: gitready
GitReadyInitializes a git repo for a python projectInstallationpip install gitreadyCommand Line Interfaceusage: gitready [--license <license>] [--pypi <project>] [-h] [-V] user/repo

Creates a new python project from scratch.

positional arguments:
  user/repo            GitHub user and repository names.

optional arguments:
  --license <license>  Which open source license to use. [default: mit]
                       [possible values: apache2, bsd, gplv3, mit, mozilla]
  --pypi <project>     PyPI name if different than the repo name.
  -h, --help           Print this help message and exit.
  -V, --version        Show version information and exit.
Package: git-rebase-chain
#git rebase-chainA tool to make gerrit-like PR chains easier to manage## UsageLet’s say that we have 4 commits,a,b,c, andd. All of these correspond to different pull requests on GitHub that are under review.Your colleague Alice lets you know thatbhas a typo insupercalifragilisticexpialidocious.js. Better update it! We switch tob, fix the typo, then rungit commit –amend.But wait! Nowcanddare tracking the wrong commit. Worse, when we look at the PRs in GitHub they show weird and unexpected changes!Fortunately, we can fix this easily withgit rebase-chain. Just run`shell > git checkout d > gitrebase-chainb--pushorigin Updating remote d to bd941f056dec5e7b0dd277c1786429f668611c28 Updating d to bd941f056dec5e7b0dd277c1786429f668611c28 Updating remote c to f6b59999b9dff86df0b6e7e0d9096946bd47c77a Updating c to f6b59999b9dff86df0b6e7e0d9096946bd47c77a `Now all of our refs, both local and remote are up to date!