Saravanan666/pypi-org huggingface dataset:
Package: gitmess
🚀 gitmess: Automated Git Commit Messages with GPT! 🚀📝 Prerequisites:Before usinggitmess, you must set up your OpenAI API key:Linux/macOS:exportOPENAI_API_KEY=<your_api_key>Windows (Command Prompt):setOPENAI_API_KEY=<your_api_key>Windows (PowerShell):$env:OPENAI_API_KEY="<your_api_key>"🖥 Usage:Generating an automatic commit message:gmActivating Auto-Push:After committing, you can choose to automatically push your commits to the repository. To activate the auto-push feature, use:gm--set-push-autoChecking the installed version:To ensure that gitmess has been installed correctly and to check its version, use:gm-vThis will display the currently installed version of gitmess.🎯 Descriptiongitmessis a revolutionary tool designed to supercharge developers' git workflows by automatically generating commit messages with the power of GPT. Keeping with theconventionalcommits v1.0.0standard, gitmess ensures that your commits remain consistent, meaningful, and time-efficient!🛠 Features:🔥Auto-Generated Commit Messages: No more time wasted thinking about the perfect commit message.📏Conventionalcommits v1.0.0 Standard: Ensures that your commits align with best practices.🤖GPT-powered: Leverages the capabilities of GPT to generate relevant commit messages.🌟 Benefits:🕐Save Time: No need to think about commit messages anymore.🔄Consistency: Follow theconventionalcommits v1.0.0standard every time.🚀Enhance Workflow: Streamline your git process.📥 Installation:Windows:Open Command Prompt as administrator.Run the following command:curl-LOhttps://raw.githubusercontent.com/0xjesus/gitmess/main/install.bat&&install.batmacOS:Open the Terminal.Use the following command to download and run the installer:curl-LOhttps://raw.githubusercontent.com/0xjesus/gitmess/main/install_gitmess.sh&&chmod+xinstall_gitmess.sh&&./install_gitmess.shLinux:Open the Terminal.Execute the following command to download and run the installer:curl-LOhttps://raw.githubusercontent.com/0xjesus/gitmess/main/install_script.sh&&chmod+xinstall_script.sh&&./install_script.sh🤔 Frequently Asked Questions:Q:How does gitmess use GPT?A:gitmess analyzes your changes and uses GPT's natural language processing capabilities to craft the perfect commit message.📜 License:This project is licensed under the MIT License. See theLICENSEfile for more details.🌐Happy coding and commit with style using gitmess!🌐
Package: git-message-hook
git-message-hookEnforcesconventional git commit messagesfor all new git repositories you create by runninggit initInstallationpipinstallgit-message-hookDocumentationDetailed docs are available athttps://git-message-hook.readthedocs.io/en/latest/.AttributionIcons made bySmashiconsfromwww.flaticon.comis licensed byCC 3.0 BY
Package: git-meta
Git meta is a small program enabling the power of system-wide status check of
all you git repositories.It usesgitpython.Installation$pipinstallgit-metaAlternatively, if you want to installgit-metafrom the sources:$pythonsetup.pyinstallYou can also install it in avirtualenvin order to test and not mess your system configuration.DocumentationThe documentation usesSphinx. To generate statics HTML
files, go to thedocsfolder and type$makehtmlUnit testingIn order to launch the tests sequence of the package, you needPytestandPytest-covinstalled.Just type$pytestat the root of the repository.Old version of git-metaThe old version of git meta can be foundhere.
Package: git-me-the-url
Git me the URL!A python package that translates references in a local git repository into
shareable URLs for popular Git hosting sites.Currently supports:GitHubGitLabBitbucketTo add your own URL translator, see this example project:https://github.com/amykyta3/gmtu-plugin-exampleInstallingInstall fromPyPiusing pip:python3 -m pip install git-me-the-urlCommand line applicationUse it for everyday link sharing with friends:Python APIEmbed in your Python application:fromgitmetheurlimportGitMeTheURLgmtu=GitMeTheURL()url=gmtu.get_source_url("my_git_repo/my_file.txt")print(url)
Package: git-migrate
Execute commands from shell file, storing last successful execution in
detached git branch.How it worksYou have some bash file(-s) with few commands inside. Each on it’s own
line. If you will run it in shell – it will execute all of them.During deploy you need to run only new commands, that was added to this
file. Think of it as a one way DB migrations that will get commands to
execute fromgit diff.Git to the resque! System will store successfull commands executions in
detached branch named.gitmigrate. Then if we will have 5 commands
and only 3 of them was successful, on next run we will not run them.Always run/include some code?First lines until two new lines will be always executed. So when you
have shebang and then 2 new lines (as it usual) – it will be executed.
Also you can add some includes after your 1st line, that will allow you
to have DSL-like functions inside your script. After which you shoudl
have two new lines.Conventions and configurationsConfiguration values are in file.gitmigrate.Configuration values with defaultsSee.gitmigrate.distas an exampleDetached branch name_gitmigrate.Path to command file(s) is.gitmigrate.*. It could be both.gitmigrate.shor.gitmigrate.pyor.gitmigrate.d/directory.
Package: gitmiller
GitMillerThis description can be foundon GitHub hereGitMiller is a tool for running Jupyter Notebooks from a (partial) Github repository. It downloads the repository in your temp folder, runs a designated notebook within it, and
removes all downloaded files afterwards.Installation$ pip install gitmillerAfter installation you can use thegitmillercommand-line tool to run your github notebooks.UsageThe command-line interface takes the following input parameters:parameterdescription-u, --usernameUsername to gain access to GitHub repository-p, --passwordPassword Github repository-t, --tokenOr use a Github token-r, --repositoryURL of GitHub repository (can be a subfolder)-n, --notebookfilename of notebook you wish to execute, this file must exist in the root folder of the (partially) downloaded folder structure.-o, --outputlocal path where GitMiller will put the executed version of your notebook-c, --configlocal path of YAML file in which you can add all mentioned paramatersGitMiller usesPapermillto run your remote notebook. Besides executing, Papermill also enables you to parameterize notebooks. If you would like to override certain variables in your notebook, add the variables and values in the config YAML file under thepapermillkey. See example below.This repository contains a folderexamplein which a notebooktest.ipynbexists. If you would like to run this notebook with GitMiller, use either:$ gitmiller -u <GITHUB USERNAME> -p <GITHUB PASSWORD>, -r https://github.com/UtrechtUniversity/GitMiller/tree/master/example, -n test.ipynb, -o <LOCAL OUTPUT-PATH>or create the following YAML file:repository: https://github.com/UtrechtUniversity/GitMiller/tree/master/example
username: <GITHUB USERNAME>
password: <GITHUB PASSWORD>
notebook: test.ipynb
output: <LOCAL OUTPUT-PATH>

papermill:
  a: 10
  b: 60and run with:$ gitmiller -c <PATH TO YAML-FILE>Note for Windows usersThe script isn't able to remove the temp-folder after the Notebook has been processed onWindowsmachines. I have tried a lot of things, but couldn't find a solution. Manually removing also turned out to be impossible when using a terminal. I give up. At the end a message is printed in which the path of the folder is mentioned so you can remove it yourself.
Package: gitmine
gitmineStop getting buried under countless Github Issues and PRs. Organize, reference, and close with ease.Based on the amazing work done by Github itself onhubandGithub CLI(released while we were working on this project. Must've been on to something). I view this as a natural extension of theghcommand for easy access to Issues and PRs from anywhere in your command line.Who is this for?I work on a lot of projects across many repositories. It was a pain in the a$$ to keep track of all the Issues I was assigned and PRs I had to review. Some tools provided a quick way to see Issues from one repository, but I needed a quick way to view, organize and open from any of these projects, thusgitminewas born.If you aren't a heavy user of Github or maybe only have one repository you focus on, this is probably more than you need.UsageCommand Line ArgumentsUsage: gitmine [OPTIONS] COMMAND [ARGS]...

  Simple command-line tool for querying assigned Issues and PR reviews from
  Github.

Options:
  -v, --verbose  Give more output. Option is additive, and can be used up to
                 three times.
  --help         Show this message and exit.

Commands:
  config  Set or Access Github Config information.
  get     Get assigned Github Issues and/or Github PRs.
  go      Open a browser page for the given repositiory / issue.ConfigIf you already have the Github CLI installed and setup, congrats! You can skip this section.gitmineautomatically piggy-backs on Github CLI's config to access your Github information.
To usegitmineyou will first need to generate a Personal Access Token. You can follow the instructionshere.gitmine config username ~git-username~
gitmine config token ~git-token~InstallationFrom PyPipip install gitmineFrom sourcepip install 'git+https://github.com/joecummings/gitmine.git'ContributingSeeContributing.mdCommon Errors and FAQ'sRunninggitmine get prswith the wrong username will not error but return nothing
Package: gitmit
This is a library for finding the commit times of all the files under a git
repository.Can be used from the commandline:$ cd /some/repository
$ gitmitOr as a library:from gitmit.mit import GitTimes
print(GitTimes(root_folder, ".").find())Options to both include:parent_dirThe relative folder to the root of the repository that we care about. The
rest of the filters are then relative to here.timestamps_forA list of globs specifying what to include (i.e. anything not covered by the
globs is ignored)excludeA list of globs specifying what to exclude after timestamps_for is taken into
accountincludeA list of globs specifying what should be re-included after exclude is
taken into accountwith_cacheBoolean saying whether we should write the resulting commit times to a file
under the .git folder that we can reuse in the future.debugCurrently the only difference with debug is outputting the commits per second
as we traverse the commits in the repository.Why/HistoryI needed this ability in my Docker client (http://harpoon.readthedocs.org) so
that I could maintain the modified times of the files in the context sent to the
docker daemon between builds on my build servers (doing a git clone sets the
modified times of the files to the time of the clone).Originally I was shelling out to git log for every file. This was slow! I then
moved to dulwich (python implementation of git) which was faster, but still
slow. Then I implemented it with pygit2 (libgit2 c bindings in python) and
decided to make it a separate library.Unfortunately it’s still not as fast as doing agit whatchanged--pretty=%atand interpreting the results, but I rather a solution that uses libraries rather
than interpreting text from the output of a program and the speed is not a
problem for reasonably sized repositories.In September 2018 I moved back to using dulwich. This is because pygit2 is a bit
of a pain because of how it pins to particular versions of libgit2, which itself
can be annoying to get installed such that pygit2 can find it.InstallationJust use pip:$ pip install gitmitChangelog0.5 - TBDSwitch to dulwich over pygit2. This is because pygit2 is a pain to install.
The downside is it is slower, but only by a few seconds.Before 0.5 no changelog was maintainedTestsInstall testing deps and run the helpful script:$ pip install -e .
$ pip install -e ".[tests]"
$ ./test.shOr use tox:$ pip install tox
$ tox
Package: gitmixin
GitmixinAn SQLALchemy mixin that can track individual fields and turn them into git repos with simple advance forward, rewind back mechanisms.DocsDocumentation on how to use the project as well as development for it can be found here. Check the projects section on Github speciifcally for the roadmap.Checkout our read the docs!TestingRun tests:python3 tests/test_githandler.pyGetting started with GitMixinA quick guide to using gitmixinInstallationFirst install gitmixin with pippip install gitmixinorpip3 install gitmixinAdding Gitmixin to your projectSQLALchemy projects typically have a database defined in models. In your models.py file or equivalent, import GitMixin near the top of the file.from gitmixin import GitMixinThen, in your SQLAlchemy class, inherit the GitMixin we just imported to give that model SQLAlchemy methods & allow it to access that models' event hooks.class Notes(Base, GitMixin):Finally in the model, add a new private attribute trackedfields, and let it equal a list of strings that you intend to track. The strings inside this list should be names of fields you want to track.class Notes(Base, GitMixin):
    __tablename__ = 'notes'
    __trackedfields__ = ['notes', 'links']
    id = Column(Integer, primary_key=True)
    notes =  Column(String(200))
    links = Column(String(200))A finished example# imports
from gitmixin import GitMixin

# SQLAlchemy
from sqlalchemy import Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base

# ...

Base = declarative_base()


class Notes(Base, GitMixin):
    __tablename__ = 'notes'
    __trackedfields__ = ['notes', 'links']
    id = Column(Integer, primary_key=True)
    notes =  Column(String(200))
    links = Column(String(200))
Package: git-mnemonic
Speakable, rememberable translations for git ref hashes[![Build Status](https://travis-ci.org/glenjamin/git-mnemonic.png)](https://travis-ci.org/glenjamin/git-mnemonic)UsageFrom inside a git repository# Defaults to HEAD
$ git mnemonic
end line grab ding# Can be given a specific revision
$ git mnemonic origin/master
line pot end bear# Will translate back to the full git hash
$ git mnemonic line pot end bear
4b63bf41e0c2369c76b6e3ce3ea40ed5fa0977c3Installpip install git-mnemonicTODOIt’d be really nice to produce a really friendly word list, that contained only
words that sounded audiably distinct and were easy to spell / type / read.
It would also be awesome to support multiple spellings of tricky words.
Package: git_monorepo
Monorepo support built aroundgit subtree.Installationpipinstallgit_monorepoUsageSimply create a mapping file calledmonorepo.ymlin the root of your
git directory:mappings:adhesive:git@github.com:germaniumhq/adhesive.gitoaas:oaas:git@github.com:germaniumhq/oaas.gitgrpc-compiler:git@github.com:germaniumhq/oaas-grpc-compiler.gitregistry-api:git@github.com:germaniumhq/oaas-registry-api.gitregistry:git@github.com:germaniumhq/oaas-registry.gitgrpc:git@github.com:germaniumhq/oaas-grpc.gitsimple:git@github.com:germaniumhq/oaas-simple.gittools:git-monorepo:git@github.com:bmustiata/git-monorepo.gitCustom BranchIf you want to use a different branch name in all the remote
repositories instead of the same name as the local branch, specify it as
such:mappings:# ...branch:master**Note**This branch name applies for both pulling *and* pushing.Squash Commitssubtreecreates the commits, including merges into the upstream
repos. This could severely pollute the history of the upstream repos.
Because of this reason, squashing is implicitly enabled.To disable squash the history into single commits, set thesquashproperty:mappings:# ...squash:falsepullTo pull the repos (including initial setup), use:gitmonopullIn case upstream changes happened in the remote repos, so a pull is
required before the push, use the--no-syncflag, so it won’t
automatically merge and mark the changes as already synchronized to the
remote repo.Implicity having apullshould be done on a clean repo, and apull--no-syncif upstream changes are present.pushTo push the repos do:gitmonopushThis takes into account the current branch name, so pushes can happen
also with branches.At the end of the operation, if something was pushed, a new file to
track the status named.monorepo.syncis created and committed
automatically. This file holds a list of commits that were pushed, so
your merges can also be dealed with correctly, by adding both entries
when solving a potential conflict for a project.mvThis renames the entry in the synchronized commits, and does the
equivalent of:gitmvold/pathnew/pathWith a special commit sogit-subtreecan find it.NoteYou still need to manually update themonorepo.ymlmanually with
the new location.NoteThe feature is currently deemed unstable.
Package: git-multi-branch
git-multi-branchClone all branches of a git repositoryInstall$ pip install git-multi-branchUsage$ git-multi-branch --help

Usage: gitmb.py [OPTIONS] URL

  Clones all the branches of a git repository using the given url. It uses
  the local ssh key of the current user to authenticate while running git
  commands.

Options:
  -d, --target-dir TEXT  Target directory to run the command from  [default:
                         ./repos]
  -c, --cache-dir TEXT   Cache directory  [default: ./.cache]
  --help                 Show this message and exit.Examples:# (Default) Clones all the branches related to the git-url
$ git-multi-branch <git-url>
Package: git-multi-repo-updater
git-multi-repo-updateris a command line tool for updating multiple GitLab or GitHub repositories with a single command.UsageGenerate an access token atGitLaborGitHuband set it as environment variable:exportGITLAB_ACCESS_TOKEN=<token>exportGITHUB_OAUTH_TOKEN=<token>exportGIT_TOKEN=<token># This one is used if previous ones are not foundProvide a list of repositories and a script or a command to run inside each of them:git-multi-repo-updater--reposrepos.txtupdate_repo.pyWhererepos.txtcould be:https://gitlab.com/<handle>/<repo-title>
https://gitlab.com/<handle>/<repo-title2>
https://github.com/<handle>/<repo-title>Try it yourself:git-multi-repo-updater\--repohttps://github.com/<handle>/<repo-title>\--branch-nameadd-hello-world-file\--commit-message"Add hello-world.txt file"\touchhello-world.txtThese steps will be executed for each specified repository:The repository will be cloned into/tmp/directory.A new branch will be created or fetched if it already exists.The command or a script will be executed inside the repository.A commit containing all the changes will be created.Newly created commit will be pushed to remote repository.A pull request will be created.[optional] A comment will be left next to the PR.[optional] The pull request will be merged.These options could be used to specify more details:OptionDescriptionTypeRequired-r--repo--reposRepo URL or a file containing repo URLsStringYes-m--commit-messageA commit message which will be used for all of the changes made.StringNo-b--branch-nameA name of a branch which will be created or used to add a commit and to create pull request from.StringNo--delayMinimum delay in seconds between API callsNumberNoEfficiencygit-multi-repo-updateris implemented in Python and uses coroutines to make multiple parallel API calls. Delays are being made after each API call in order not to get throttled.RoadmapMake API calls to GitHubPackage and release to PyPiRun command as command line toolStand-alone executable file download in Github releases.Make API calls to GitLabSupport different API callsAdvanced features:Merge PRs which have all requirements like approvals met.Developmentmake venv- will create virtual env with dev dependencies.make check- will run Flake8, MyPy and PyTest checks.Related projectsThis tool was inspired by:https://github.com/earwig/git-repo-updaterhttps://github.com/gruntwork-io/git-xargs
Package: git-name
git-namea git extension and python package for turning hashes into memorable namesinstallfrom pypipip install git-nameor from github masterpip install git+https://github.com/CircArgs/git-name.gitUsageshellCircArgs$gitname-h
usage:gitname[-h][-f][-lLENGTH]word_or_hash

converthashestomemorablenames

positionalarguments:word_or_hash

optionalarguments:-h,--helpshowthishelpmessageandexit-f,--from`fromhash`flagusedtodenoteargumentisahash.-lLENGTH,--lengthLENGTH`hashlength`(default=7)truncatetheinputoutputhashtothislength

CircArgs$gitnameefa8f31
tenoccupiednuts

CircArgs$gitname-f"ten occupied nuts"efa8f31

CircArgs$gitname-f"five fat frogs"a42cd68# use names with git instead of hashesCircArgs$gitcheckout$(gitname-f"five fat frogs")pythonfromgit_nameimportNameGeneratornum=142152565ng=NameGenerator()name=ng.generate_name(num)print(name)# 'eight upward buttons'name_num=ng.generate_num(name)print(name_num)#142152565print(num==name_num)#Trueprint(ng.generate_hash_from_name(name,7))#8791375print(ng.generate_name_from_hash(8791375,7)#'eight upward buttons'
Package: git-nb
Python package to execute basic git command in notebook.InstallationUsing pip :pipinstallgit_nbExampleSet your configfromgit_nbimportcfgcfg.username="yourusername"cfg.email="youremail"Clone a repositoryIf the repository is private, you will be invited to write your password.importgit_nbfromgit_nbimportcfgcfg.repo_name="yourrepo"git_nb.git_clone()Pullimportgit_nbgit_nb.git_pull()
Package: git-networkx
Git-NetworkXPort ofhttps://github.com/hoduche/git-graphto NetworkXInstallPyPipip install git-networkxGitpip install git+https://github.com/CircArgs/git-networkx.gitDemofromnetworkx.drawing.nx_pydotimportwrite_dotfromgit_networkximportGitNX,Commit#everythingAll=GitNX('my/repo/path/that/has/a/git/directory')#networkx Digraph representing all nodes of the git repo#Commits#notice the path does not have to be .git in case you have used a different nameCommits=GitNX('my/repo/path/located/in/.got',"c")#networkx Digraph representing only commits of the git repo#again, the results of GitNX is just a networkx.DiGraph and as such you can do anything you would on such an object[nforninAllifisinstance(n,Commit)]Suppose you had a log like the following:commit 9a99a4d85cb14005ca829e2cab8f626b4034b981 (HEAD -> master, dev)
Author: CircArgs <quebecname@gmail.com>
Date:   Fri Aug 14 22:05:30 2020 -0400

    I like dogs

commit 80798c310455976e08fedd9b367794692ebb54a6
Author: CircArgs <quebecname@gmail.com>
Date:   Fri Aug 14 22:04:58 2020 -0400

    add file2 with text

commit 8c7f9cea1f6323d793cd035e2178636d6ebf0a36
Author: CircArgs <quebecname@gmail.com>
Date:   Fri Aug 14 22:04:28 2020 -0400

    add file 1thenG=GitNX(".","lch")print(list(G.neighbors(Commit("80798c310455976e08fedd9b367794692ebb54a6"))))# [Commit('8c7f9cea1f6323d793cd035e2178636d6ebf0a36')]print(list(G.predecessors(Commit("80798c310455976e08fedd9b367794692ebb54a6"))))# [Commit('9a99a4d85cb14005ca829e2cab8f626b4034b981')]print(list(G.predecessors(Commit('9a99a4d85cb14005ca829e2cab8f626b4034b981'))))# [LocalBranch('dev'), LocalBranch('master')]NodesThis table shows what nodes can be in a graph. TheLetters denote the filters for creation of the graph as the second positional argument togit_networkx.GitNXi.e. thenodesargument.As shown in above examples, theDiGraphfromGitNXcan be filtered by checkingisinstanceagainst the Node Classes below or by filtering by a an instance of one of the classes.Overall Node Class:GitNodeNode kindLetterNode ClassNode kindLetterNode ClassblobbBlobremote branchrRemoteBranchtreetTreeremote headdRemoteHeadcommitcCommitremote serversRemoteServerlocal branchlLocalBranchannotated tagaAnnotatedTaglocal headhLocalHeadtaggTagBy default all nodes are added to the DiGraph.# you can get your commits, branches and the head of your local repo simply with lchG=GitNX('../git_networkx_test/',"lch")
Package: gitno
gitnoGitno is a command-line tool that generates.gitignorefiles based on the templates available in thegithub/gitignorerepository.InstallationYou can installgitnousing pip:pipinstallgitnoUsageCreate aGITHUB_ACCESS_TOKENin your settings then add it to your environment variablesInitialize a local copy of the .gitignore files by running:gitnoupdateTo generate a .gitignore file on the current working directory, run the generate command followed by the template number or name:gitnogenerateTo see a list of available templates, run the list command:gitnolistContributingContributions are welcome! Please seeCONTRIBUTING.mdfor details.Test coverageLicenseThis project is licensed under the MIT License - see theLICENSEfile for details.