Saravanan666/pypi-org huggingface dataset:
Package: git-archive-deep
Deep archive command forgitFeaturesArchive a git repository with all sub-modules.InstallationYou can installGit Archive DeepviapipfromPyPI:$pipinstallgit-archive-deepUsageLet's say you have a repository in a directoryMyTool/and you want to archive version 2.1, which is taggedv2.1.git archive-deep v2.1 ./MyToolThis will create a zip file namedMyTool-v2.1.zipthat contains the repository along with its sub-modules.This tool is similar togit-archive-all, but it allows you to specify a
git ref instead of archiving the currently checked out commit. It is really just simple wrapper around Git that callsgit archive <ref> .in the repository directory, but then reads.gitmodules(if it exists), determines the SHA1 for each
sub-module usinggit rev-parse(callinggit rev-parse v2.1:path/to/submodulewill print the SHA1 for the commit that is checked out in submodule
located atpath/to/submodulefor versionv2.1), and then just calls itself for each sub-module recursively, merging each archive into the main repo.ContributingContributions are very welcome.
To learn more, see theContributor Guide.LicenseDistributed under the terms of theMIT license,Git Archive Deepis free and open source software.IssuesIf you encounter any problems,
pleasefile an issuealong with a detailed description.CreditsThis project was generated from@cjolowicz'sHypermodern Python Cookiecuttertemplate.
Package: git-archiver
Git ArchiverA tool designed to mass archive a collection of git repositories on a file system into a format that can be put into "cold storage".This project is still early in developmentArchived FormatWhen running an archive into specific structure, shown below:dst/
    enchant97/
        git-archiver/
            branches/
                pre.<archive-type>
            tags/
            all.bundle
            HEAD.<archive-type>
            meta.jsonInstallThere are many ways of installing and running a Python app. These are the recommended methods.pipxpipxis used when you want it installed on the system for a user.python3 -m pip install --user pipx
python3 -m pipx ensurepath

pipx install git+https://github.com/enchant97/git-archiver.git

git-archiver --helpDockerThis method allows running the program inside a docker container.docker build -t git-archiver .

docker run --rm -it git-archiver <app args here>LicenseThis project is Copyright (c) 2022 Leo Spratt, licences shown below:CodeApache License - Version 2.0. Full license found in `LICENSE.txt`
Package: gitargus
GitArgusPython utility to synchronize state of git workspaces for developers who use multiple machines. Uses AWS free tier DynamoDB to store the state. Can automatically pull changes if fast-forwarding is possible. Currently version only supports Unix systems.Installationpip install gitargusAWS Infrastructure setupYou can create a freeAWSaccount and use the always-free allowance to run GitArgus. Consult AWS documentation on how to perform the required steps.Create a DynamoDB table with a String partition key named 'hostname'. 1 read and write capacity should be enough, but turning on capacity auto scaling is recommended.Install aws-cli to each machine you will run GitArgus on. Log in with a user and save it's credentails who has permission to write to the DynamoDB table. GitArgus will pick up these credentials.ConfigurationCreate the '.gitargus' directory in your home folder, and create the configuration file 'config.yml':hostname: machine
root: /home/user/Workspace
repositories:
    - repo1
    - repo2
    - project1/repo1
    - project2/repo1
    - project2/repo2
aws:
    dynamodb:
        table: git
timezone: Europe/Budapesthostname- the name of the machine, will be used as key in DynamoDBroot- the directory where the repositories arerepositories- list of the repositories to handle, can handle multiple directory levelsaws.dynamodb.table- the name of the DynamoDB tabletimezone- timezone of the timestamps, useful in case of remote machines in different timezonesUseageYou can start the process with the following command:python -m gitargusEither you can run manually or set up a cron job.LogsThe log file is located at~/.gitargus/gitargus.log.User InterfaceThe server.py file can be used for a stop-gap method to check the contents of the DynamoDB table. First install uvicorn, then run it withuvicorn server:app. Then use the urlhttp://127.0.0.1:8000/{hostname}to access the json response. This is a temporary solution and will be removed before realese.A MacOS/iPadOS/iOS application is in the very early stages of development.
Package: gitarootools
gitarootools — command line tools to work with Gitaroo Man game dataGitaroo Manis a rhythm action video game for PlayStation 2. This set of tools allows
you to work with data from the game, converting game files to more viewable formats. In
some cases, files converted this way can be edited, converted back to a game format, and
reinserted into the game.InstallationThe easiest way to installgitarootoolsis to usepip:pipinstallgitarootoolsUsageSee each tool's help and usage by runninggm-<toolname>-hIncluded toolsArchivegm-xgmpack: pack files into an XGM containergm-xgmunpack: unpack files from an XGM containergm-pakpack: pack files into a PAK container (Gitaroo Man Lives)gm-pakunpack: unpack files from a PAK container (Gitaroo Man Lives)Audiogm-imcpack: pack subsongs into an IMC audio containergm-imcunpack: unpack subsongs from an IMC audio containergm-subsongconv: convert a subsong to another formatgm-subsong2[subimc|wav]: convert multiple subsongs to the specified formatImagegm-imx2png: convert IMX images to PNGgm-png2imx: convert PNG images to IMXOthergm-gmo2animnames: extract animation names from a GMO model (Gitaroo Man Lives)ResourcesGitaroo PalsDiscord server for help and supportIssue Tracker
Package: git-assistente
LicenseScript/Biblioteca criada com o intuito de automatizar tarefas do GitUm Assistente do Git criado para ajudar, automatizar e ser mais produtivo.
Script criado para iniciantes aprenderem a usar o Git (por isso sempre retorna os comandos usados) e também profissionais serem mais rápidos (pelo fato de ser muito rápido).Instalação:pip install git-assistenteExecutar:Derivado do Debian:git-assistenteDerivado do Ubuntu:python3 -m git-assistenteLicense
Package: git-author
git-author, a git command for managing multiple authors.Home PageProject home page ishttps://github.com/cfelder/git-authorUsageConfigure multiple users, e.g.:git config --global gitauthor.guest.name "Guest User"
git config --global gitauthor.guest.email "guest.user@example.com"

git config --global gitauthor.john.name "John Doe"
git config --global gitauthor.john.email "john.doe@example.com"Since version 1.1.0 the committer can be set to match the author using:git config --global gitauthor.committerisauthor trueGet a list of configured users:$ git-author

The following authors have been configured:

           guest:  Guest User <guest.user@example.com>
            john:  John Doe <john.doe@example.com>

         default:  Christian Felder <webmaster@bsm-felder.de>Select specific user:git-author johnFinally commit your changes as usual in this session using:git commitLicenseThe git-author library is open source software released under theLGPL-3.0+ license(http://www.gnu.org/licenses/lgpl-3.0.html).PEP8 Compliancegit-author is PEP8 compliant.DownloadPackage download is available athttps://pypi.python.org/pypi/git-author.Installgit-author can be installed from the Python Package Index usingpiporpip3.$ pip3 install git-authorAsgit-authorneeds to change environment variables in your shell, it is
necessary to source the git-author script. Please add an alias pointing to
thegit-authorscript to your environment, e.g.:alias git-author='source /usr/local/bin/git-author'Git repositoryYou can download the latest source athttps://github.com/cfelder/git-author
Package: gitautopush
gitautopushWatch a local git repository for any changes and automatically push them to GitHub.Useful as a live synchronization tool for teaching.
Say you've got a Jupyter notebook (or a markdown file) that you are populating with code while
you are teaching a class. As you add content to the file, you'd like students
to have access to the "latest" version at any moment in time.gitautopushlets you automatically track the latest changes to a git repository,
and automatically push them to GitHub. You
can then ask students to visit a GitHub or nbviewer link, and they
will be able to see any changes that you've made.See the GIF below for an example.InstallationYou can install with pip:pip install gitautopushUsageFirst, make sure that you've got a GitHub repository cloned to a local folder.Next, rungitautopushand point it to that folder:gitautopush /path/to/my/repo/foldergitautopushwill begin watching this folder for any changes. When it
finds them, it will commit them and push the folder contents to GitHub.
It will also display some links that you can share with students to help
them follow along.ParametersBelow are parameters you can use to customize the behavior of Gitautopush.--sleep <INT>- the amount of time (in seconds) to wait in between
attempts to synchronize.--path <STRING>- a path to the folder you'd like to watch and synchronizeTutorial via an example use-caseHere's a common use-case forgitautopush:You're teaching a Software Carpentry bootcamp and you'd like to do your work
in a Jupyter Notebook. You have a "master copy" that you're working from, but you
don't want to give the whole thing to students ahead of time. Your plan is to
do your work in an empty notebook as students watch, and you'd like students
to have access to the latest version of the notebook at all times.First, youcreate an empty GitHub repositorywhich we'll callgitautopush-demo.
Next, we'll create a folder where we'll be doing our work:Next, youclone this empty repository to your computer:git clone https://github.com/choldgraf/gitautopush-demoNow, rungitautopushand point it to the new folder. We'll
tell it to sleep for 10 seconds after each check:gitautopush --path ./gitautopush-demo --sleep 10gitautopushwill print a few useful links, and begin checking the
folder for any changes. When it finds one, it will commit the change to
the repository and push the result. It will also print annbviewer linkfor any Jupyter notebook that is changed. You can share these links with
your students.Finally, open a new terminal window and use it to launch an application
(e.g. Jupyter Lab, Jupyter Notbeook, or your own text editor) to edit
the content.As changes are made, note the links that are provided and share them
with your students.AcknowledgementsThis tools was first thought up by John Lee, then adapted as a Python module
by Chris Holdgraf.
Package: gitback
gitbackMakes a backup of all your repositories and gists from GitHubInstall(On Linux you'll need to usesudo)From PyPIpip3installgitbackFrom GitHubpip3installgit+https://github.com/donno2048/gitbackUsageYou can also usegit backupinstead ofgitback.usage:gitback[-h][-n][-P][-s][-f][-z][-q][-u][-p][-r|-g]MakesabackupofallyourrepositoriesandgistsfromGitHuboptionalarguments:-h,--helpshowthishelpmessageandexit-n,--nameUseacustomnameforyourbackup[default:backup]-P,--pathUseacustompathforyourbackup[default:currentworkingdirectory]-s,--sshUsesshcloning[default:http]-f,--fullClonewithfullgithistory-z,--zipMakeazipfileofthebackup-q,--quietDon't see cloning progress-u,--usernameYourGitHubusername-r,--reposBackuponlyrepos-g,--gistsBackuponlygistsExampleLet's say I want to backup only my gists, and I want a zip file:gitback-udonno2048-g-z
Package: gitbackhub
gitbackhubA script to backup / mirror GitHub repositories.ConfigGet yourself apersonal access tokenon GitHub that has thereposcope.Config file in~/.config/gitbackhub/config.ini.[main]user=GitHubUserNameaccess_token=AccessTokendirectory=/path/to/target/directory[user:GitHubUserName][user:AnotherGitHubUserName][org:GitHubOrgName][org:AnotherGitHubOrgName][repo:SomeGitHubUser/some-repo][repo:YetAnotherGitHubUserName/another-repo][repo:YetAnotherGitHubOrgName/yet-another-repo]Make sure the file is not readable by anybody but yourself since it contains your GitHub token.Help$gitbackhub--help
Usage:gitbackhub[OPTIONS]Options:--access-tokenTEXT--userTEXT--directoryDIRECTORYThedatadirectorytocloneto--configPATH--helpShowthismessageandexit.
Package: git-backups
Script to back up a git repo to a Gitlab instance.Usage:Create a config file (at.env)exportGITLAB_URL=https://your.custom.gitlab.instanceexportGITLAB_USERNAME=usernameexportGITLAB_TOKEN=5v90m4u8nycw984yThen runsource.env
gitbakgit@github.com:jazzband/django-robots.gitThis will create a projectdjango-robotsunder thejazzbandgroup on the target Gitlab instance.Helpusage: main.py [-h] [--project PROJECT_NAME] [--group GROUP_NAME] source

positional arguments:
  source                Git repository URL

optional arguments:
  -h, --help            show this help message and exit
  --project PROJECT_NAME
                        Name of the destination Gitlab project. Will be inferred from
  --group GROUP_NAME    Group under which the destination project will be categorised (optional)CreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.
Package: git-backup-tool
Git BackupSmall CLI which helps to clone all user repositories on github.com, gitlab.com, bitbucket.com.UsageProvide the following parameters to the cmd:-h,--helpShowthishelpmessageandexit-tACCESS_TOKENYourGithubAPIAccessToken
-pDESTINATIONBackupdestinationpath
--mirrorMirrorrepositories
-uUSERNAMEUsernamefilteringgContributionJust create a PR, no guidlines at the moment ;)
Package: gitbatch
Batch-clone you Git reposWhat:Define all your Git repos and the folder structure they sould be organized (if you have one) in a YAML file and then just run the script. It uses the Git CLI for that.If you want to clone repos by SSH, make sure your keys are set and working.Why:I had a problem:whenever I had to use a new PC at work or at home, I had to cloneseveralGit repos. This quickly became aPITA, so I created this small Python script to do that for me.FeedbackAll and any feedback, suggestion, improvement and/or bug-fix is highly appreciated. This is a small script but quite useful, so I hope it will also help others...FutureI hope to keep improving it. My task list is, so far:Support parameters on the command line:Prefix PathConfig FileGit Key Location and/or User/PassFunction to manage the YAML from the command line (CRUD the config)Clone repositories inparallelError handlingPackage as PyPyUse a Git library (such as GitPython) instead of the CLIOnce again, any and all suggestion and feedback is much appreciated.
Package: git-bbb
Brisk Blame Browser for Git ⚡git-bbbis a wraper aroundgit blame, that lets you seamlessly warp
between different revisions.Features ✨Sensible TUI made withPrompt
ToolkitSyntax highlighting thanks toPygments!)Seamlessly switches between revisions in just one keypressShows you where the lines of a commit are in the fileUses.git-ignore-revsfile as an input to--ignore-revs-fileby defaultVi style key bindingsSearch functionalityComing soon: customizability viagit configComing soon: seamlessly browse through file history, even if it was moved
multiple timesComing soon: highlight contributions made by a given authorInstallation# Install git-bbb via pip
pip install git-bbbUsage# Installing git-bbb will add a "git bbb" command
git bbb file/in/the/repoKey bindingsUseh&jor↓&↑to move to the
next/previous blame lineEnterto switch (warp) to the highlighted revision, orPto go to its ancestor.Srunsgit showfor the commit indicated by the cursor.uto go back to the previously viewed revision - a.k.a.undo.ctrl+rtoredoprevious warp.ctrl+J&ctrl+Kmove the whole
document view up and downStepping between the lines of the currently highlighted revision:H- first,L- last,J- next,K- previous.ggandGwill make git bbb go to the first and last
line, respectivelyCtrl+dandCtrl+uwill scroll
half a page up and down, respectivelyPage Up&Page Downdo what they are supposed to do/&?to search through file contents. This works
mostly in the same way as in Vi(m). UsenandNto
cycle through results.qto quit...many more to come
Package: git-bigfile
git-bigfile is a port to python / fork of Scott Chacongit-media.
It allows you to use Git with large files without storing the file in Git itself.ConfigurationConfigure the filter and transportBy running:$ git bigfile config [--global]Or manually:First setup the attributes filter settings:(once after install)
$ git config --global filter.bigfile.clean "git-bigfile filter-clean"
$ git config --global filter.bigfile.smudge "git-bigfile filter-smudge"Next you need to configure git to tell it where you want to store the large files.
There are two options:Storing locally in a filesystem pathStoring remotely via sftp (should work with any SSH server - requires
paramiko)Here are the relevant sections that should go either in ~/.gitconfig (for global settings)
or in clone/.git/config (for per-repo settings):[git-bigfile]
    transport = <local|sftp>

# settings for local transport
[git-bigfile "local"]
    path = <local_filesystem_path>

# settings for sftp transport
[git-bigfile "sftp"]
    hostname = <host>
    username = <user>
    path = <path_on_remote_server>All sftp settings (except path) will be passed to paramiko.SSHClient connect
method. You can set: port, password, pkey, key_filename, timeout… Refer to
paramiko API.Setup the .gitattributes file to map extensions to the filter(in repo - once)
$ echo "*.tar.gz filter=bigfile -crlf" > .gitattributesStaging files with those extensions will automatically copy them to the
bigfile cache area (.git/bigfile) until you run ‘git bigfile push’ wherein they
are uploaded.  Checkouts that reference bigfile you don’t have yet will try to
retrieve them from cache, otherwise they are downloaded when you run ‘git
bigfile pull’.UsageTo configure the filter and/or the transport to use:$ git bigfile configThen:(in repo - repeatedly)
$ (hack, stage, commit)To push to the server any committed bigfile:$ git bigfile pushYou can also check the status of your bigfiles via:$ git bigfile statusWhich will show you files that are waiting to be uploaded and how much data
that is. If you want to delete the local cache of uploaded bigfiles, run:$ git bigfile clearYou can add a bigfile that doesn’t match the extensions defined in
the .gitattributes by running:$ git bigfile add <huge_file>Which will add <huge_file> to .gitattributes and to the index.To expand a bigfile you don’t have locally, run:$ git bigfile pullInstallinggit-bigfile requires Python 2.5, 2.6 or 2.7.
It has been tested on MacOS X and linux.To install, run:$ pip install paramiko (to use sftp transport)
$ pip install git-bigfileCopyrightOriginal work Copyright (c) 2009 Scott Chacon.
Modified work Copyright (c) 2012-2013 Benjamin Bertrand.
See LICENSE for details.
Package: gitbinding
Fully git command binding for python, compatible with all git and python 2 & 3 version.Installationpip3 install gitbindingUsagefromgitbindingimportGitgit=Git(path=None,direct_output=True)"""path:working directory, None = use current directory.direct_output:if direct_output set to False, the output is redirect to command/function return."""now you can run any git command likegit.init(),git.clone("gitrepo destination"),git.commit(),git.push(),git.config()etc.git command with "-" can be replaced with "_" like git rev-parse to git.rev_parse()you can also put git command argument in separate function args likegit.clone("gitrepo","destination").when git.clone() finished without error, the path will automatic move to clone destination.change git binto change git binary location, use:git.gitbin = "path/to/git/binary"
Package: gitbio
GitBio CLIproject that shows your bio (or every person) from GitHub in CLI.RequirementsPython 3.9.2 and pip packages described inrequirements.txtGetting StartedReady To UseJust runpip install gitbio(Windows) orpip3 install gitbio(Linux/MacOS). Then rungitbiocommand.ContributingIf You have problem with running this project usingpython gitbio.pyor You want to add new features, you can:Create Issue On This RepoFix Problem Using Pull Request. please, followthese instructionsThanks for support. If there will be more contributing people, I will add list of contributors.LicenseThis Project is licensed under the MIT License.
Package: gitbit
UsageRun the program from terminal as:gitbit <option> <directory><option>can be either be left blank to do anAdd->Commit->Pushto the master branch or it can be:-s for status-l for log-r for hard reset-i for initialization-c for clone-p for pulling from master branch<directory>can either be a relative or an absolute directory OR it can be left blank to run the package in the pwd(Present Working Directory)Examplegitbit-i~/Documents/abc#Results in the directory abc/ being initialized as a git repogitbit-l#Will display the git log of the pwdgitbit-c#Will prompt for a url and then clone that repo in the pwdgitbit-p~/Documents/Code#Will pull your code from the remote repo into the local git repogitbit#Will add, commit, push everything in the pwd to its remote repo
Package: git-blackhole
Continuous backup and recoverable trash can for GitThe aim ofgit-blackholeis to connect any of your repositories to
a single repository (“blackhole” repository) to which you can push any
commits — WIP commits, branches no longer needed, and useless
stashes.There are three main features ofgit-blackhole:Continuous backup.  You can usegit-blackholeto
continuously backup commits in background to a remote repository
(or actually any repository) called blackhole repository.Rungit blackhole initand then setuppost-commithook to
rungit blackhole push.  See the help ofgit blackhole pushfor the details.By combining withgit-wipcommand, you can backup/share
uncommitted changes as well.Sharing local repository state.  Sincegit-blackholecan
push commits and the location of HEAD to the blackhole repository,
the state of a repository in one machine is accessible from other
machines.For example, if you forget to push a commit from your desktop (to
the usual remote) but want to resume the work from your laptop,git blackhole warpwould be helpful.Recoverable trash can.  Usegit blackholetrash-branchandgit blackholetrash-stashesto remove branches and stashes from
the local repository after sending them to the remote blackhole
repository.  They are stored remotely as ordinary branches so that
you can recover them easily.