Saravanan666/pypi-org huggingface dataset:
Package: release-me
Creating releases from browser can be a bit tedious if you already wrote the
release notes and prepared packages in your beloved terminal. But fear not my
friend, this simple wrapper makes it possible to do the finishing touches
without having to switch to the browser.QuickstartInstalling this package is as simple as running:$ pip install release-meThis being out of the way, we must now obtain the personal access token that
this client will use to interact with Github’s API. How to get one is neatly
described onGithub’s personal access token page.Now that we created the token, we must inform our tool about it. We do this by
settingRELEASEME_TOKENenvironment variable that contains the token:$ export RELEASEME_TOKEN=our-token-from-githubNow we are ready to create some releases (and then delete them once we
discover that our code sucks and create them again once we fix most of the
bugs). But before we can proceed, we must write down release notes:$ cd /home/tadej/personal/release-me
$ cat <<EOF > release.notes
> This is the initial release of release-me package.
>
> I would like to say thank you to my kids for being a good sports and
> getting to bed early, which gives me time to write dummy release notes.
> EOFThat should do it. Now, we would also like to host our python package on
release page, just because we can. So we will build a tarball that will be
added to release. You can leave out this step if adding assets to release is
not something you would like to do. So, building a package:$ python setup.py sdist
running sdist
[pbr] Writing ChangeLog
[pbr] Generating ChangeLog
[pbr] ChangeLog complete (0.0s)
...
Creating tar archive
removing 'release-me-0.3.0' (and everything under it)Now we can finally promote0.3.0tag intadeboro/release-merepository
to full release namedThe best release ever:$ releaseme create -r tadeboro/release-me -t 0.3.0 -n release.notes \
>   -l "The best release ever" -a dist/release-me-0.3.0.tar.gz
[INFO] - Creating release for tag tadeboro/release-me 0.3.0
[INFO] - Uploading asset dist/release-me-0.3.0.tar.gz for 5837083And this is it. We are done.We can have a look at the fruits of our labor by runninggetcommand. Yep,
we have a get command to:$ releaseme get -r tadeboro/release-me -t 0.3.0
[INFO] - Getting release for tag 0.3.0
{
  "created_at": "2016-07-17T16:58:03Z",
...
  "url": "https://api.github.com/repos/tadeboro/release-me/releases/5837083",
  "zipball_url": "https://api.github.com/repos/tadeboro/release-me/zipball/0.3.0"
}And when we realize that releasing our code after drinking n beers was not the
brightest idea we had this week, we can remove the release by running:$ releaseme delete -r tadeboro/release-me -t 0.3.0
[INFO] - Getting release for tag 0.3.0
[INFO] - Deleting release for tag 0.3.0More documentationThere is no more documentation. If you feel you need more information, feel
free to read the sources.
Package: release-mgr
release-mgrA simple tool for managing software releases on GitHub.This is a polyglot tool, so it aims to supports all kinds of Version metadata files for
all languages. I've added the ones that I use every day but feel free to send a PR with
the version file for your favourite programming language.Installationrelease-mgris available on pypi:pip3 install --user release_mgrUsageUsage: release-mgr [OPTIONS]

  A simple tool for managing software releases on GitHub.

Options:
  -v, --version TEXT        Specify the version to go to
  -l, --pre-release         Indicates this is a pre-release
  -d, --draft               Indicates this is a draft release
  -r, --repo TEXT           The repository to create the release on in
                            :owner/:repo format, will attempt to parse from
                            git remotes if not given

  -t, --title               If given use the release name as the markdown
                            title, otherwise title is omitted for Github style
                            formatting

  -m, --minor               Bump minor version
  -j, --major               Bump major version
  -p, --patch               Bump patch version
  -s, --skip-version-files  Don't try to update version metadata files
                            (package.json, setup.py etc.)

  --skip-upload             Don't try to create a release on github and don't
                            push the commits

  --help                    Show this message and exit.Example runchasinglogic@raza ~/Code/release-mgr master λ release-mgr --patch
Creating release 0.1.2 8cc48996b099bdb4d2e04e6eeb7a2598381baf68
Previous version 0.1.1 0076879f4ca72a5e30a023c5f83dbcbb34a62f58
Pre-release? False
Draft release? False
Repository chasinglogic/gh-release
============= Release Notes ============
# Release 0.1.2

- 8cc4899 fix: Return True if **any** version file is updated
- 5473ff9 fix: git/ssh urls end with .git
- 429e675 fix: Stage the version file when updated

# Contributors to this Release

- Mathew Robinson <mathew@chasinglogic.io>

Does this look correct? (y/N) y
Updated version in: pyproject.toml
Enumerating objects: 5, done.
Counting objects: 100% (5/5), done.
Delta compression using up to 12 threads
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 298 bytes | 298.00 KiB/s, done.
Total 3 (delta 2), reused 0 (delta 0), pack-reused 0
remote: Resolving deltas: 100% (2/2), completed with 2 local objects.
To github.com:chasinglogic/release_mgr.git
   8cc4899..4e89ce6  master -> master
Total 0 (delta 0), reused 0 (delta 0), pack-reused 0
To github.com:chasinglogic/release_mgr.git
 * [new tag]         0.1.2 -> 0.1.2
Package: release-new
READMEThis package eases the creation of new releases for
a python package versioned with mercurial.
It assumes mercurial as vcs and semantic versioning.
Also, the version has to be managed by a variablenumversioninside a file__pkginfo__.py.It takes care to :update the version in the file__pkginfo__.py(required)update the changelogcreate a commit with only this changestag the commit.The new version,patch,minorormajor, depends on the option-r/--releasepassed as parameter.
Theautooption reads the commit message and determines the release type
according to conventional commit.The primary use case is to haverelease-newinside a tox rules for cubicweb
cubes.You can userelease-new --preview-changelogorrelease-new -cto preview the
changelog that will be generated.It does not:release to pypiThe release should be done by the CI, see the.gitlab-ci.yml.It can be installed withpip install release-new.
Package: release-notes-generator
# Setuppip install release-notes-generatorThis will provide a self-documenting command line tool under the name:release_notesYou can ask for help as you would expect:release_notes –helpYou will need to set your github access token to use it:export GITHUB_API_TOKEN = <token># Usage
You can fetch release notes like:release_notes getfor auto_pipelineBy default this will look for an existing release and try to parse out the pr numbers from it’s description. Alternatively, you can use a file:release_notes getfor auto_pipeline –source pr_numbers.txtEither way will output to the console release notes of the following form:` h2. SOME TITLE CHANGE_TYPE: UI DESCRIPTION: Some descriptions JIRA TICKET:LIMS-123PULL REQUEST: 123 RISK: LOW RISK DESCRIPTION: Some description `Optionally redirect to a file:release_notes getfor auto_pipeline > release_notes.txt# How this Works
You can look atcli.pyfor an example of how to use this script.Essentially,cli.pyruns the following where the token variable is looking forGITHUB_API_TOKENto be set.`python ReleaseNoteGenerator(token,repository_name=repository_name).release_notes()ReleaseNotesFormatter.output(notes) `ReleaseNoteGeneratorparses the PR numbers from the latest release, if no release exists it will return nothing. It then passes the PR numbers to the pr fetcher which grabs the descriptions. A good entry point it to look atReleaseNoteGenerator.release_notes# Future Work
This is a quick and dirty initial implementation and we should expand this for easy reuse.[Complete] Iteration 1: Packaging and Interface Features
- command line interaction to run with a repository_name arg` # print output to the screen release_notes auto_pipeline--print`- packaging for easy pip install and use across LIMS projects (ie. use in individual release scripts)
- document APIIteration 2: Granularity and Robustness Features
- expose the PRFetcher so that we are not coupled to fetching the initial list purely from
- add ability to diff the latest release and previous release and auto generate pr numbers (is this in the ARMS release script?)
- auto generate tag and release adding the PRs to the release notesOther Features:
- tests
- auto ignore markdown comments
- filter out heading fields in the description and only parse the one line description
- include full pull request links
Package: releaserr
releaserrSimple, purpose-built release manager for @gotmax23's projectsLinksreleaserr project hubreleaserr git.sr.ht reporeleaserr trackerreleaserr mailing list(~gotmax/releaserr@lists.sr.ht)ContributingSeeCONTRIBUTING.md.LicenseThis repository is licensed underSPDX-License-Identifer: MIT AND UnlicenseIn general:Code is licensed underMIT.Templates inreleaserr/new/dataare licensed underUNLICENSE.
Package: releases
What is Releases?Releases is aSphinxextension designed to help you
keep a source control friendly, merge friendly changelog file & turn it into
useful, human readable HTML output. It’s compatible with Python 3.6+, and may
work on Sphinx versions as far back as 1.8.x, though 4.x and up are
recommended and generally all we will support.Specifically:The source format (kept in your Sphinx tree aschangelog.rst) is a
stream-like timeline that plays well with source control & only requires one
entry per change (even for changes that exist in multiple release lines).The output (when you have the extension installed and run your Sphinx build
command) is a traditional looking changelog page with a section for every
release; multi-release issues are copied automatically into each release.By default, feature and support issues are only displayed under feature
releases, and bugs are only displayed under bugfix releases. This can be
overridden on a per-issue basis.Some background on why this tool was created can be found inthis blog post.For more documentation, please seehttp://releases.readthedocs.io. For a
roadmap, see the maintainer’sroadmap page.NoteYou can install the development version viapip install-egit+https://github.com/bitprophet/releases/#egg=releases.
Package: releases1c
releases1cPackage manager for release.1c.ru, ver: 1.0.0InstallationInstall packagepip install --upgrade agent1c_metricsUsageSet authentication environmentWindows:set RELEASES1C_USERNAME=<username>
set RELEASES1C_PASSWORD=<password>Linux, Mac:export RELEASES1C_USERNAME=<username>
export RELEASES1C_PASSWORD=<password>Get infoGet list of available packagespython -m releases1c infoGet info about versions for packagepython -m releases1c info Platform83Get list of files for provided version and packagepython -m releases1c info Platform83 8.3.23.1912Get list of mirrors for provided package, version and filetypepython -m releases1c info Platform83 8.3.23.1912 setuptc.rarContributionInstall package in editable modepip install -e .Change version (major/minor/patch)bumpver update --patchBuild and publish the packagepoetry publish --build
Package: releases-manager
Python releases manager - pyrmanPython library that can be used to manage releases for packages that you owns on PyPI.Featureslist packages that you ownlist releases for packages that you ownunpublish (remove) a specific release for one of your packagesUsage (CLI)Unpublish a releasepyrmanreleaserm<package><version>You can find out more information on how to use CLI by using--helpoptionpyrman--helpUsage (Python)frompyrman.clientimportReleaseManagerClientpyrman=ReleaseManagerClient(url)pyrman.authenticate(username,password)releases=pyrman.list_releases("my-package")forreleaseinreleases:pyrman.remove_release("my-package",release.version)
Package: releasetasks
Mozilla Release Promotion Tasks contains code to generate release-related Taskcluster graphs.Free software: MPL licenseFeaturesTODOTestingExample test invocation using docker:docker run –rm -vpwd:/src -ti rail/python-test-runner /bin/sh -c “cd /src && tox”Or to run a single test:docker run –rm -vpwd:/src -ti rail/python-test-runner /bin/sh -c “cd /src && .tox/py27/bin/py.test –verbose –cov=releasetasks –cov-report term-missing –doctest-modules releasetasks/test/firefox/test_updates.py::TestUpdates::test_requires”
Package: release-version
Release versionYet another tool for bumping version number and updating changelog.UsageInstall by running:pipinstallrelease-versionAdd following inpyproject.tomlfile in the root directory of your project:[tool.release-version]filename="pyproject.toml"pattern="version =\"(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)\""changelog="CHANGELOG.md"# optionalRelease new versions by running:release-versionpatch
release-versionminor
release-versionmajorLicenseMIT
Package: releasy-uff
ReleasyReleasy is a tool that collects provenance data from releases
by parsing the software version control and issue tracking
systems.PapersCurty, F., Kohwalter, T., Braganholo, V., Murta, L., 2018. An Infrastructure for Software Release Analysis through Provenance Graphs. Presented at the VI Workshop on Software Visualization, Evolution and Maintenance.How to useBasic Usage$ python -m releasy [release-name] <command> [options]E.g.:Show information about the release 1.0.0$ python -m releasy project download https://api.github.com/repos/gems-uff/releasy/issues
$ python -m releasy 1.0.0 showInstallationpip install releasy-uffAvailable CommandsShow project information$ python -m releasy project overviewDownload project issues$ python -m releasy project download https://api.github.com/repos/gems-uff/releasy/issuesShow release information$ python -m releasy 1.0.0 showExport prov-n from a release$ python -m releasy 1.0.0 prov
Package: rele-les-transformations
RelÃ© makes integration with Google PubSub straightforward and easy.Motivation and FeaturesThePublish-Subscribe patternand specifically the Google CloudPub/Sub libraryare very powerful tools but you can easily cut your fingers on it. RelÃ© makes integration
seamless by providing Publisher, Subscriber and Worker classes with the following features:Powerful Publishing APIHighly Scalable WorkerIntuitive Subscription ManagementEasily Extensible MiddlewareReady to go Django/Flask integrationCLIAnd much more!What it looks like# Publish to the topicimportrelerele.publish(topic='photo-uploaded',data={'customer_id':123})# Subscribe to the Pub/Sub topicfromreleimportsub@sub(topic='photo-uploaded')defphoto_uploaded(data,**kwargs):print(f"Customer{data['customer_id']}has uploaded an image")What's in the name"RelÃ©" is Spanish forrelay, a technology thathas played a key rolein
history in the evolution of communication and electrical technology, including the telegraph,
telephone, electricity transmission, and transistors.InstallRelÃ© supports Python 3.6+ and installing viapippip install releor with Django integrationpip install rele[django]or with Flask integrationpip install rele[flask]QuickstartPlease see our documentation to get started.You can also read more about ithereRunning TestsDoes the code actually work?make test
Package: relengapi-tooltool
# TooltoolThis is tooltool.  Tooltool is a program that helps make downloading large
binaries easier in a CI environment.  The program creates a json based manifest
that is small compared to the binaries.  That manifest is transmitted to the
machine that needs the binary somehow (checked in, included in tarball, etc)
where the machine will run tooltool to download.When using the fetch mode, the program will check to see if the file exists
locally.  If this file does not exist locally the program will try to fetch
from one of the base URLs provided.  The API that tooltool uses to fetch files
is exceedingly simple.  the API is that each file request will look for an http
resource that is a combination of an arbitrary base url, a directory that is
named as the hashing algorithm used and the hashing results of each file stored.Example, using base url of “http://localhost:8080/tooltool”, algorithm of “sha512”
and a file that hashes to “abcedf0123456789”, tooltool would look for the file
at “http://localhost:8080/tooltool/sha512/abcdef0123456789”.  If there is a local
file that has the filename specified in the manifest already, tooltool will not
overwrite by default.  In this case, tooltool will exit with a non-0 exit value.
If overwrite mode is enabled, tooltool will overwrite the local file with the
file specified in the manifest.## StructureThis repository contains both the tooltool client –tooltool.py– and the
tooltool server component, which is a
[RelengAPI](https://github.com/mozilla/build-relengapi) blueprint.If you want to use the client, just copy outtooltool.py– it has no
dependencies.## DevelopmentHack on tooltool as you would any RelengAPI blueprint.  That means, roughly,
creating a virtualenv and runningpip install -e .[test]to install the
blueprint and all of its dependences, including those for running tests.Send pull requests through GitHub.Both the client and the server components are covered by Travis, via thevalidate.shscript which you can run yourself.
Package: releng-tool
releng-toolOverviewWhen dealing with a project that depends on multiple packages, assets may be
found in multiple locations and may require various methods to extract, build
and more. releng-tool can be used to process a defined set of
projects/packages which identify where resources can be fetched, how packages
can be extracted and methods to patch, configure, build and install each
individual package for a target root.For detailed documentation on the releng-tool project, seereleng-tool's documentation.RequirementsPython2.7 or 3.4+Host tools such asGit, scp, etc. may be required depending on the
project being processed (e.g. if a package's sources fetch from a Git source,
a Git client tool is required to perform said fetch).InstallationThis tool can be installed usingpip:pipinstallreleng-tool(or)python-mpipinstallreleng-toolFor Arch Linux users, this package is also available on AUR:Arch User Repository - releng-toolhttps://aur.archlinux.org/packages/releng-tool/UsageThis tool can be invoked from a command line using:releng-tool--help(or)python-mreleng-tool--helpExamplesExamples of releng-tool projects can be found inreleng-tool's examples repository.
Package: relent
# RELENT
Linter for for our new [release engine hotness](https://github.com/RHInception/?query=re-).[![Build Status](https://api.travis-ci.org/RHInception/relent.png)](https://travis-ci.org/RHInception/relent/)For documentation see the [Read The Docs](http://release-engine.readthedocs.org/en/latest/libraries/relent.html) documentation.
Package: relenv
RelenvRelenv creates re-producable and re-locatable python builds. The builds
created with Relenv are re-producable in the sense that all binaries for the
builds are built from source. These builds are re-locatable meaning you can
move the root directory around on the filesystem; and even different machines
of same architecture.Relenv can be thought of in a similar way to projects like virtualenv and
pyenv. The difference between Relenv and these projects is that each relenv
contains the entire python interpereter. Relenv environments can be moved
around and shared with others.Useful LinksDocumentationIssue TrackerSource CodePython Packages
Package: releso
Reinforcement Learning based Shape OptimizationThis repository holds a Library/Framework written by Clemens Fricke for
Reinforcement Learning based Shape Optimization. Please look into the
Documentation for information on how it works. The instruction on how the
documentation can be built is given below as well as the instruction on how the
package can be installed. It is currently not available frompip, this might
come in the future.Documentation generationInstall and usage instructions are provided in the documentation of the
project. The documentation can be built with the use of sphinx which is apythontool to generate documentation.The sphinx packages can either be installed in the project python environment
or in a separate environment. If it does not matter in which python environment
sphinx is installed ignore the first two lines.The following command line calls create a conda environment with all necessary
dependencies for building the documentation.(base)$condacreate-nsphinxpython=3.9(base)$condaactivatesphinx(sphinx)$pipinstallsphinxsphinx-rtd-themeThe documentation is built by executing the following command inside the folderdocs/. After executing the command the documentation should be available
inside the folderdocs/build/html/(sphinx)$makehtmlInstallationThis section covers the installation process of the framework and its
prerequisites. The first thing to note is that with version 0.1.0 the strict
dependency onsplinepyis not present anymore. But if the
geometry is to be parameterized by a Spline and the method of Free Form
Deformation is to be used to deform a mesh,splinepyis
necessary.PrerequisitesTo useReLeSOthe following packages have to be installed:pydantic<2stable-baselines3tensorboardhjsonThepydanticpackage currently needs to be on version 1.*, we welcome
anyone wanting to updaterelesoto the newpydanticversion.The packages can be installed via pip or conda with the following commands:pip(activation of the venv should be done beforehand)(.venv)$pipinstallpydanticstable-baselines3tensorboardhjsonconda(base)$condacreate-nrelesopython=3.9"pydantic<2"tensorboard(base)$condaactivatereleso(releso)$pipinstallstable-baselines3hjsonThe quotation marks are necessary for some command lines likezsh. But from
testing,bashis also ok if you use them even though they are not necessary.If the spline-based shape optimization functionality is needed, the packagesplinepyis needed. Please visitsplinepyon githubfor installation
instructions.DevelopmentTo develop the framework further the sphinx package should also be installed
with the currently used sphinx html themesphinx_rtd_theme.
This can be done via:(releso)$pipinstallsphinxsphinx_rtd_themeFrameworkAfter installing all prerequisites the framework itself can be installed by
running the command below in the main repository folder.Non-development(releso)$pipinstall.Development(releso)$pipinstall-e.
Package: relevanceai-chains
Relevance AIA simple chain1. Install and loginInstall:pip install relevanceaiLog in and create a project and api key:import relevanceai as rai
rai.login()or if you are in an automated environment, set these environment variables:RELEVANCE_API_KEY=XXXX2. Getting startedchain = rai.create(
    name = "My chain",
    description = "The greatest chain"
)3. Add steps to the chainCreate a step for the chainstep = PromptCompletion(
    prompt="Hello world",
)You can run and test the individual step.step.run()Once you are comfortable with the step you can add it bychain.add(step)4. Run and test the chainRun the chainchain.run()5. Configuring outputBy default it'll return the full state and all outputs from each step. You can control it by:chain.set_output(["answer"])A chain with flexible inputs1. Give your chain flexible inputsAdd input parameterschain = rai.create(
    name = "My chain",
    description = "The greatest chain"
    parameters = {
        "name" : {"type" : "string"}
    }
)2. Define the parameters inside a stepstep = PromptCompletion(
    prompt="Hello world my name is ${name}",
)