Saravanan666/pypi-org huggingface dataset:
Package: gitcommonsync
[![Build Status](https://travis-ci.org/wtsi-hgi/git-common-sync.svg?branch=master)](https://travis-ci.org/wtsi-hgi/git-common-sync)[![codecov](https://codecov.io/gh/wtsi-hgi/git-common-sync/branch/master/graph/badge.svg)](https://codecov.io/gh/wtsi-hgi/git-common-sync)[![PyPI version](https://badge.fury.io/py/gitcommonsync.svg)](https://badge.fury.io/py/gitcommonsync)# Git Common Sync_A tool to synchronise common files between Git repositories._## Features- Programmatically synchronises git repositories according to a specification.- Supports synchronisation of:- Files and directories.- Directories managed by [git-subrepo](https://github.com/ingydotnet/git-subrepo).- Content generated using templates and project specific values.- Ansible support.## How to use### Prerequisites- git >= 2.10.0- git-subrepo >= 0.3.1- python >= 3.6- rsync >= 3.1.1### Installation#### Ansible Module```yaml- gitcommonsync:repository: http://www.example.com/repository.gitauthor_name: Ansible Synchroniserauthor_email: team@example.comkey_file: /custom/id_rsafiles:- src: /example/README.mddest: README.mdoverwrite: false- src: /example/directory/dest: configtemplates:- src: /example/ansible-groups.sh.j2dest: ci/before_scripts.d/start.shvariables:message: "Hello world"overwrite: truesubrepos:- src: http://www.example.com/other-repository.gitdest: subrepos/other-repositorybranch: masteroverwrite: true```## Development### SetupInstall both library dependencies and the dependencies needed for testing:```bash$ pip install -q -r requirements.txt$ pip install -q -r test_requirements.txt```### TestingTo run the tests and generate a coverage report with unittest:```bash./test-runner.sh```If you wish to run the tests inside a Docker container (recommended), build `Docker.test`.## Alternatives- Powerful but complex Ruby based alternative from the Puppet community: https://github.com/voxpupuli/modulesync.## License[MIT license](LICENSE.txt).Copyright (c) 2017 Genome Research Limited
Package: gitcomp
gitcompA simple python package with a CLI to compare GitHub users and repositories by associating agit_scoreto each
entry which is a weighted sum of features mapped to a score.git_scorefor auseris calculated on the basis offollowers, followers to following ratio, number of public gists and number of organisationsa user is part of.
For apublic repository, the determining factors arenumber of forks, if the repository itself is forked or not,
number of stars and number of watchers.InstallationInstall via pip:pipinstallgitcompusage: gitcomp [-h] [-u user_name [user_name ...] | -r repo [repo ...]] [-t output_t] [-o out]

gitcomp A CLI utility to compare the vital stats of GitHub repositories

optional arguments:
  -h, --help            show this help message and exit
  
  -u user_name [user_name ...], --user user_name [user_name ...]
                        -u, --user <username...> The GitHub username(s) to query against.
                        Multiple usernames can be queried at a time by providing a space
                        separated argument list.
                        
  -r repo [repo ...], --repo repo [repo ...]
                        -r, --repo <repo> The public GitHub repository to query against
                        where repo takes the form: <user/repo>
                        Example: -r octocat/Spoon-Knife
                        
  -t output_t, --type output_t
                        -t, --type <type> Default: ascii. Choose the format of output. 
                        All output is dumped to STDOUT unless output file is specified
                        using -o, --output flag.
                        The types available are: json: Show the result as JSON
                                                 csv: Format the output to CSV 
                                                 ascii: Show the result as an ASCII Table 
                                                 html: Show output as HTML Table
                                                 
  -o out, --output out  -o, --output <out_file> Output to out_file, defaults to STDOUT.ExamplesComparing Usersgitcomp-uRohitrajak1807avaish1409Comparing Repositoriesgitcomp-ravaish1409/VideoChatBotRohitrajak1807/algorithmsSpecifying output typeASCII Table (Default)gitcomp-uRohitrajak1807avaish1409-tASCIIJSONgitcomp-uRohitrajak1807avaish1409-tjsonCSVgitcomp-uRohitrajak1807avaish1409-tcsvHTML Tablegitcomp-uRohitrajak1807avaish1409-thtmlSpecifying output filegitcomp-uRohitrajak1807avaish1409-tjson-ores.jsongitcomp-uRohitrajak1807avaish1409-tcsv-ores.csvgitcomp-uRohitrajak1807avaish1409-thtml-ores.htmlgitcomp-uRohitrajak1807avaish1409-ores.txtHistorySee release notes for changeshttps://github.com/avaish1409/gitcomp/releasesDevelopment pattern for contributorsCreate a forkof
themain gitcomp repositoryon GitHub.Make your changes in a branch named something different frommainand titled as per your contribution, e.g. create
a new branchdocumentation-fixes.Create a pull request.Please follow thePython style guide for PEP-8.Licensegitcomp is licensed under theMIT License.
Package: git-config
git_configGet git config as a dictionaryInstallationpipinstallgit_configUsagefromgit_configimportget_config# Global git configconfig=get_config()config["user"]["name"]# Roshan Acharyaconfig["user"]["email"]# acharyaroshan2357@gmail.com# Local git configconfig=get_config("local")config['remote "origin"']["url"]# git@github.com:coderosh/git_config.git
Package: gitconflict
Conflicts is a solution to check whether git branches conflict with each otheror not without doing actual merge.
get_first_conflict(list_of_heads) will return a tuple
(HEAD1, HEAD2, file_containing_conflicting_changes) describing first found
conflict or None if there are no conflicts at all.
The package also provides “git-conflict” script.
Run it as “git conflict HEAD1 HEAD2…”. It returns 1 if its arguments
are heads which do not conflict with each other, and 0 otherwise.
Both function and script accept arguments in tree-ish form, for instance:
master, 123abcde(SHA), HEAD^^.Written and tested with Python 3.2 runtime.
Package: gitconsensus
GitConsensusThis simple project allows github projects to be automated. It uses "reaction" as a voting mechanism to automatically
merge (or close) pull requests.Consensus RulesThe file.gitconsensus.yamlneeds to be placed in the repository to be managed. Any rule set tofalseor ommitted
will be skipped.You can rungitconsensus initto start with a template configuration in the current working directory.# Which version of the consensus rules to useversion:3# Add extra labels for the vote counts and age when mergingextra_labels:false# Don't count any vote from a user who votes for multiple optionsprevent_doubles:true# The following only applies to pull requestspull_requests:# Minimum number of votersquorum:5# Required percentage of "yes" votes (ignoring abstentions)threshold:0.65# Only process votes by contributorscontributors_only:false# Only process votes by collaboratorscollaborators_only:false# When defined only process votes from these github userswhitelist:-alice-carol# When defined votes from these users will be ignoredblacklist:-bob-dan# Number of hours after last action (commit or opening the pull request) before issue can be mergedmerge_delay:24# Number of votes from contributors at which the mergedelay gets ignored, assuming no negative votes.delay_override:10# When `delayoverride` is set this value is the minimum hours without changes before the PR will be mergedmerge_delay_min:1# Require this amount of time in hours before a PR with a license change will be merged.licensed_delay:72# Require this amount of time in hours before a PR with a consensus change will be merged.consensus_delay:72# Do not allow license changes to be merged.license_lock:true# Do not allow consensus changes to be merged.consensus_lock:true# Number of hours after last action (commit or opening the pull request) before issue is autoclosedtimeout:720VotingVotes are made by using reactions on the top level comment of the Pull Request.ReactionVoteYesNoAbstainLabel OverridesAny Pull Request with aWIPorDONTMERGElabel (case insensitive) will be skipped over.CommandsAuthenticationgitconsensusauthYou will be asked for your username, password, and 2fa token (if configured). This will be used to get an authentication
token from Github that will be used in place of your username and password (which are never saved).InitializationInitialize the configuration for a specific project. If no template is provided therecommendedsettings will be used.
All settings come from thegitconsensus_examplesproject.gitconsensusinit[TEMPLATE]MergeMerge all pull requests that meet consensus rules.gitconsensusmergeUSERNAMEREPOSITORYCloseClose all pull requests that have passed the "timeout" date (if it is set).gitconsensuscloseUSERNAMEREPOSITORYInfoGet detailed infromation about a specific pull request and what rules it passes.gitconsensusinfoUSERNAMEREPOSITORYPR_NUMBERForce CloseClose specific pull request, including any labels and comments that normally would be sent.gitconsensusforcecloseUSERNAMEREPOSITORYPR_NUMBERForce MergeMerge specific pull request, including any labels and comments that normally would be sent.gitconsensusforcemergeUSERNAMEREPOSITORYPR_NUMBER
Package: git-conventional-version
GIT-CONVENTIONAL-VERSIONFind version automatically based on git tags and commit messages.The tool is very specific in its function, so it is very flexible.You can use it as a part of many different integrations and it will not break your process.Installpython3 -m pip install git-conventional-versionUsageGet new bumped final version:gcvGet new bumped release candidate version:gcv --type=rcGet current (old) version, 0.0.0 if none exists:gcv --oldExample of CI automation script:old=$(gcv --old)
new=$(gcv)
# check if version bump would happen
if [ ! $new == $old ]; then
    # if yes, update setup.cfg
    sed -i "s/^version.*/version = $new/g" setup.cfg
    # and commit release
    git add setup.cfg
    git commit -m "$new"
    git tag "$new"
    git push --tags
    git push
fiVersion formatsTags are equivalent to versions, no suffix or prefix is added or interpreted.
Formats followhttps://www.python.org/dev/peps/pep-0440/.Final versionStandard tag is in the format\d+\.\d+\.d+ie.1.0.0. It can be divided intomajor.minor.patchversions.It is automatically bumped based on commits messages and old version of the same type (look atGit commit message conventionbelow).Pre-release versionsPre-release versions bumps are calculated based on last final version, its expected bump and old version of the same pre-release type.Release candidate versionFormat\d+\.\d+\.d+rc\d+ie.1.0.0rc1.Developmental versionFormat\d+\.\d+\.d+dev\d+ie.1.0.0dev1.Alpha versionFormat\d+\.\d+\.d+a\d+ie.1.0.0a1.Beta versionFormat\d+\.\d+\.d+b\d+ie.1.0.0b1.Local versionAlso, local version can be created from commit sha and old version:\d+\.\d+\.d\+.+ie.0.0.0+79ad.Git commit message conventionConvention is based onhttps://www.conventionalcommits.org/en/v1.0.0/(it's good!).
At the moment, only the following rules apply (I usually use only these but more can be added easily):Start commit with 'fix:' or 'fix(.*):' to bump patch version.Start commit with 'feat:' or 'feat(.*):' to bump minor version.Include in the commit line with 'breaking change:' to bump major version.Automatic changelogOn branch where your version tags are present, you can generate changelog:gcv-logFull changelog is generated and printed to stdout. You can redirect it to a file.
Assumes that you are about to release next version if not on commit with final version.NoticesAutomatically handling many types of version tags in git is more complicated than it initially seems like.
Package: git-covdiff
This is …An utility to support your coverage task.Determine the missing which appeared newly in latest commit by comparing the hunks of the commit to coverage analyzed.
To use this, first, measure the project coverage at the target revision to generate.coverage.Requirementscoverage >= 3.6b1pygit2 >= 0.17.3 (and libgit2http://libgit2.github.com/)I don’t test with earlier versions.
Package: gitcrawl
Gitcrawlexports required modules from python codebakes you a nice environments.yml for your condaaims to ease the headache that comes with transferring conda environmentsallows you to create a neat environments.yml for any python project you feed itDocsMotivationCurrently there is no way known to me to transfer conda environments in a non-cumbersome way across operating systems. The current commands as stated in the official docs are:conda env export > environment.yml 

conda env export --no-builds > environment.yml 

conda env export --from-history.ymlExample:Within your environment, callconda install numpy=1.17.5conda env exportproduces a .yml file including version numbers, local dependencies + hashes:- numpy=1.19.5=py38h6ced74f_1
- olefile=0.46=pyh9f0ad1d_1
...conda env export --no-buildsproduces a .yml file including version numbers and local dependencies:- numpy=1.19.5
- olefile=0.46
...conda env export --from-historyproduces a .yml file with no version information included, Also it includes only packages which have ben manually installed into the environment.- numpy
- pandas
...If you want to get a better grasp of the commandshereis a small test-case.Above behavior makes transferring conda environments across systems often quite challenging. More often than not, you'll end up writing the entire environment.yml by hand.GitcrawlI wrote gitcrawl out of the desire to make life a bit easier for my colleagues and me, as we often exchange/test/experiment with various code.Gitcrawl offers another handy feature: You can clone any python repository and it will create a environment.yml for you, thus saving you a lot of time and helping you keep your system neat and tidy when you just simply want to test some code.
(Especially nice, if not even a requirements.txt is provided)Note:This tool is a workaround  and PoC, keep this in mindAdjusting the resulting environment.yml is sometimes unavoidableInstall:Way 0:pip install gitcrawlWay 1The manual way (if you want to tinker around):Clone the repository:git clone https://github.com/nsultova/gitcrawl.gitUse the provided gitcrawl-env.yml to create a conda environment:conda env create -f gitcrawl-env.ymlActivate the new environment:conda activate gitcrawl-envVerify that the new environment was installed correctly:conda env list(If you prefer to use pip you should be able to extract what you need from the environments.yml)Usage:Way 0gitcrawl -s ../repo/to/be/parsedWay 1cd <path/to/gitcrawl>python3 -m gitcrawl.gitcrawl -s ../repo/to/be/parsedThe code is designed in a heavily interactive way. If you're lazy you can set the--leave-me-aloneflag. This will make gitcrawl run trough all channels and ask you only if there are several installation candidates to choose from.In either ways--helpand the docs are your friends. <3Have a lookWorkflowNotesThis code relies on:findimportsrequirements-parserpip_search..as for now pip-search isMake sure you have them installed!
Package: git-create-repo
git-create-repoCreates local and remote git repository from command line. This tool is intended forPython 3.Installpip install git-create-repoOrpython setup.py installAlso make sure you havegitinstalled.Usagegit_create.py [-h] [-p] [-s] [-n NAME]Arguments-h, --help            show this help message and exit
-p, --private         private repository
-s, --ssh             switching from https to ssh remote url. Using
                      git@github.com... instead of https://github.com...
-n NAME, --name NAME  name of remote repositoryMake sure youcdinto the correct folder you want to create a repository in.Create public repositorygit_createCreate private repositorygit_create -pAdding Remote repository nameYou can specify a different name for the remote repository with-n. Otherwise the local repo name will be used.Switching Remote URLBy default, remotes are added by HTTPS. You can change this to SSH by adding-s, assuming you have your SSH keys setup.Github UsernameThe tool simply fetches the username fromgit config user.name. If you don't have this set, the tool with prompt you to enter it beforehand.Next stepsYou will be prompted to enter your password and a description. The description can be skipped by simply pressingenter. If your password is incorrect, you will be prompted again.If the above is successful, you will now have a repository created on your Github account.NoteThis will create a defaultREADME.mdfile including the name of your repository if none exist.It is also suggested to create your own.gitignore, so you can ignore what files you don't want commited beforehand. All files get committed otherwise.DevelopmentWindowsInstalling Development Dependencies:Runbuild installTesting ScriptUsetestfolder generated frombuild testto run script. This is to ensure your actual git repository is not compromised.The other build targets are used to upload to Pypi.LinuxInstalling Development DependenciesEnsure you haveGNU Makeinstalled. You can install this withsudo apt-get install make.To install development dependences, runmake install.Testing ScriptUsetestfolder generated frommake testto run script. This is to ensure your actual git repository is not compromised.The other build targets are used to upload to Pypi.FutureOther features that can make this tool more usable.Please let me know in the issues tab.
Package: git-crecord
Aboutgit-crecordis a Git subcommand which allows users to interactively
select changes to commit or stage using a ncurses-based text user interface.
It is a port of the Mercurial crecord extension originally written by
Mark Edgington.git-crecord allows you to interactively choose among the changes you have made
(with line-level granularity), and commit, stage or unstage only those changes
you select.
After committing or staging the selected changes, the unselected changes are
still present in your working copy, so you can use crecord multiple times to
split large changes into several smaller changesets.Installationgit-crecord assumes you have Python 3.9 or later installed as/usr/bin/python3.git-crecord ships with a setup.py installer based on setuptools.
To install git-crecord, simply type:./setup.py installThis will install git-crecord itself, its manpage and this README file into
their proper locations.Alternatively, to install it manually, symlinkgit-crecordinto
the directory where Git can find it, which can be a directory in
your$PATH:ln -s $PWD/git-crecord ~/.local/bin/git-crecordNow you should have a new subcommand available for you.When you’re ready to commit some of your changes, type:git crecordThis will bring up a window where you can view all of your changes, and
select/de-select changes.
You can find more information on how to use it in the built-in help
(press the ‘?’ key).git crecordsupports most popular options ofgit commit:--author=,--date=,--message=,--amend,--signoff.LicenseThis program is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later
version.This program is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied
warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE.  See the GNU General Public License version 2
text for more details.You should have received a copy of the GNU General Public
License along with this package; if not, write to the Free
Software Foundation, Inc., 51 Franklin St, Fifth Floor,
Boston, MA  02110-1301 USAAuthorsFor the list of contributors, see CONTRIBUTORS.
Package: git-credential-helpers
git-credential-helpersCollection ofgit-credentialhelpers,
focused on interacting with private repos.Installationgit-credential-helpersis available on PyPI, and can be installed withpip.python3-mpipinstallgit-credential-helpersA number of scripts with names of formgit-credential-$NAMEwill now be in$PATH.ConfigurationYou must configure git to use the helpers appropriately by adding an entry
ingitconfig.github-app helperIn yourgitconfigfile, add the following section:[credential "https://github.com"]helper=!git-credential-github-app --app-key-file <path-to-your-app-rsa-key-file> --app-id <id-of-your-github-app>useHttpPath=trueIf you are doing this in a docker container, I'd recommend putting this under/etc/gitconfig.
Else, try~/.gitconfig
Package: git-credential-netconf
git-credential-netconfGit credentials management made easy.InstallationUsepiporpip3to installgit-credential-netconfpipinstallgit-credential-netconforpip3installgit-credential-netconfIntroductionCredential management in Git should not be difficult to use or configure, but
(unfortunately) looking at the existing tools, it is difficult to even think
about it, let alone configure them without errors.NOT. ANY. MORE!Presentinggit-credential-netconf, an easy yet powerful way to manage your
Git credentials by harnessing the power ofGnuPG!Usage OverviewThe following guide assumes you have a GPG key and you have installedgit-credential-netconf.Create a.netconffile in your home directory.touch~/.netconfStart by filling in your username and password:[conf]login=yournamepassword=very-secret-passwordThe.netconffile uses configuration file format.Read more about.netconffile.Encrypt your.netconffile withgpggpg--recipientyourname@example.com--output~/.netconf.gpg--encrypt\--sign~/.netconfAnd remove your original.netconffor security:shred-u~/.netconfTell Git to use it⚠️ Make sure that~/.local/binis in$PATHgitconfig--globalcredential.helper'netconf --debug'Read more about flags forgit-credential-netconfhere.Now use git without hassle!gitpushThis will promptgit-credential-netconfto decrypt the~/.netconffile
usingGPGand fetch theusernameandpassword, among other values.You'll be asked for the password toGPGprivate key when decrypting.Usage Detailsusage: git-credential-netconf [-h] [-g GPG] [-d] [-f FILE] [-q]
                              {get,store,erase} ...

Easy credential management using GPG.

positional arguments:
  {get,store,erase}     The credential operation to use.

optional arguments:
  -h, --help            show this help message and exit
  -g GPG, --gpg GPG     The `gpg` program to use.
  -d, --debug           Show output of `gpg` (it prints into `stderr`).
  -f FILE, --file FILE  The `.netconf.gpg` file to use.
  -q, --quit-on-failure
                        Do not let Git consult any more helpers if an error is
                        encountered while decryption.

git-credential-netconf is licensed under MIT license. Visit
<https://github.com/arunanshub/git-credential-netconf> for more info.About.netconffile.netconfcan be used as a direct replacement for.netrcfile, with the
advantage of being more convenient to use.The section nameYou can use any name for the section name, but usingconfis the convention.The keysThis table shows the equivalent values for.netconf,.netrcandgit-credentialkeys:.netconf.netrclikegit-credentiallogin,user,usernameloginusernamemachine,hostmachinehostpathpathpasswordpasswordpasswordport1,protocolprotocol1: Ifportis an integer, it is used as ahost:portformat.Why another tool?All other tools are very hard to configure properly.UsingPerlis as clear as mud.Python is easy to use, maintain and is very portable.LicenseMIT