Saravanan666/pypi-org huggingface dataset:
Package: venuspy
Venus: For those that get bored of looking at their wallpaperVenus aims to be a cross-platform tool to automatically change your desktop wallpaper using images fromUnsplash. By default, all images are stored in the system's temporary directory, this way their disposal is handled by the operating system.Venus also handles using images that work with your resolution.Note for the adventurous -> set venus as a startup program. This way you can see what awaits you with each reboot :)InstallationInstall using pip3Linux/OSXpip3 install venuspyWindowspy -m pip install venuspyUsageJust type venus!Linux/OSXvenusWindowspy -m venusYou can also supply search terms to the command:venus landscape nature carConfigVenus can be configured for specific search terms to get a category of images.Edit the config file located in:~/.config/venus/configBy default, the search terms are empty, which means the image selection will be random. To choose what kind of images you want, enter search terms separated by commas.Here is an example:SEARCH_TERMS = landscape,nature,carSearch terms in the command will overwrite those from the config.To get images of a specific Unsplashcollection, use its id:COLLECTION_ID = 1053828Note: IfCOLLECTION_IDis set, theSEARCH_TERMSis ignored.By default all images are stored as temporary files in the temp directory of the operating system. To change the location where the images are stored, edit the OUTPUT_PATH option.Here is an example:OUTPUT_PATH = /home/user/PicturesVenus has the option of using a timer to change your wallpaper given an interval in seconds.Here is an example that changes the wallpaper every 60 seconds (1 minute):WAIT_TIME = 60By default a image is requested with the resoluton of your screen. If you need to change that for any reason (if your screen resolution is not available by Unsplash and you are getting a 404 image as your wallpaper), edit the SCREEN_RESOLUTION option. Here is an example:SCREEN_RESOLUTION = 1920x1080Venus supports usingpywalas an addon.
To use pywal firstinstall it,
then enable it in the config file:USE_PYWAL = TrueTo limit the number of files stored locally and prevent filling your disk, set theCACHE_ITEMSoption (0is infinite)CACHE_ITEMS = 10Current Version 1.0.3 - verified working onFeh 3.5Gnome 3.28KDE Plasma 5.15.4Sway 1.2macOS High SierramacOS MojaveWindows 10How to ContributeCheck for open issues or open a fresh issue to start a discussion
around a feature idea or a bugheretag for issues that should be ideal for people who are not very familiar with the codebase yet.Forkthe repositoryon
GitHub to start making your changes to themasterbranch (or branch off of it).Write a test which shows that the bug was fixed or that the feature
works as expected.Send a pull request and bug the maintainer until it gets merged and
published. :) Make sure to add yourself toAUTHORS.
Package: venus-tempest-plugin
This is a venus tempest plugin package. Tests can be run as a tempest plugin
against any venus-enabled OpenStack cloud.Please fill here a long description which must be at least 3 lines wrapped on
80 cols, so that distribution package maintainers can use it in their packages.
Note that this is a hard requirement.Free software: Apache licenseDocumentation:https://docs.openstack.org/venus/latestSource:https://opendev.org/openstack/venus-tempest-plugin/Bugs:https://bugs.launchpad.net/openstack-venusFeaturesTODO
Package: venvarium
venvariumInstallationpython-mpipinstallvenvariumExamplefromvenvariumimportVEnv# Create the virtual environmentENV_PATH='myproject/myenv'venv=VEnv(ENV_PATH)# Run Python, PIP, or any other package or programvenv.python('-c','print("hello, world!")')venv.pip('install','--upgrade','pip')venv.run_package('flask')# See all installed packagespkgs=venv.installed_packages()print(pkgs)# Get the entry pointsentry_points=venv.entry_points().get('my_entry_point')print(entry_points)
Package: venv-autouse
This package helps managing venv in different locations for different scripts.
You don’t have to manually care about calling a script with the according venv.
All you need is provide a requirements file and import this module in the files which require the venv.
This module needs to be installed system-wide or in every venv you use to call files.
However, if you are executing files from within a venv, you will loose the current venv.The versioning followssemantic versioning.FileWhen you have a python scriptfile.pyand it needs a venv, you can simply addimport venv_autouse.fileat the top of the file, and write the requirements filefile.req.txt.
It also uses therequirements.txtfile in the directory of the file.
All this will create a venv directory.file.venvin the same directory.DirectoryThis is the same, except that it uses a venv shared in the directory of the file to save space when possible.
Package: venvception
VenvceptionVenvception is a Python library designed to simplify the process of creating and using temporary virtual environments when you have good reason to stay in the same process. It provides a context manager that automates the setup of a virtual environment, installs specified packages from arequirements.txtfile, and ensures that the environment is used for the duration of the context.Why?In distributed contexts, it can be convenient to ship a requirements specification rather than pre-baking containers. This library is quick and dirty.InstallationTo install Venvception, run the following command:pipinstallvenvceptionQuick Start / UsageHere's a simple example to get started with Venvception:fromvenvceptionimportvenvfrompathlibimportPath# Specify the path to your requirements filerequirements_path=Path("path/to/your/requirements.txt")# Use the venv context manager to create and activate the virtual environmentwithvenv(requirements_path)asvenv_path:# Import a module from the requirements.txtimportyour_module# You can also access the path to the virtual environment via `venv_path`print(f"Virtual environment created at:{venv_path}")Ensure yourrequirements.txtfile is properly formatted and accessible at the specified path.Accessing the Virtual Environment's PathThe context manager yields the path to the temporary virtual environment, allowing you to interact with it directly:withvenv(Path("requirements.txt"))asvenv_path:print(venv_path)ContributingContributions to Venvception are welcome! Please feel free to submit pull requests, report bugs, or suggest features through the issue tracker.LicenseVenvception is released under theMIT License.
Package: venv-clean
venv-cleanTool that finds python virtual environments in your machine, displaying interesting data, such as disk usage and packages installed.
It gives the user the chance to delete one or more virtual environments to free disk space.UsageThe package can be used directly on your terminal. The only argument it receives (for now) is the path where you want to look for virtual environments.$venv-clean-husage:venv_clean[-h][-pPATH]PythonVirtualEnvironmentfinder&manageroptionalarguments:-h,--helpshowthishelpmessageandexit-pPATH,--pathPATHpathwheretolookforvirtualenvironmentsThrough a TUI, the user will be displayed with the data.InstallationLatest release through PyPI:$pipinstallvenv_cleanDevelopment version:$gitclonegit@github.com:jcapona/venv-clean.git$cdpi-gpio-api$pipinstall-e.ContributeFeel free to open issues, report bugs or open pull requests.
Package: venvctrl
Python API for interacting with virtual environments.Why?The only real interface provided by a virtual environment is the CLI. This
package wraps the command line tools to provide a more friendly programmatic
interface.Creating A Venvfromvenvctrlimportapiapi.VirtualEnvironment('/some/path/here').create()Installing Packagesfromvenvctrlimportapivenv=api.VirtualEnvironment('/some/existing/venv')ifnotvenv.has_package('venvctrl'):venv.install_package('venvctrl')else:venv.uninstall_package('venvctrl')Moving A Venvfromvenvctrlimportapivenv=api.VirtualEnvironment('/some/existing/venv')venv.move('/some/new/path')Alternatively, use the CLI.venvctrl-relocate\--source=/some/existing/venv\--destination=/some/new/path\--moveLicense(MIT License)

Copyright (C) 2015 Kevin Conway

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to
deal in the Software without restriction, including without limitation the
rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
sell copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
IN THE SOFTWARE.ContributingAll contributions to this project are protected under the agreement found in
theCONTRIBUTINGfile. All contributors should read the agreement but, as
a summary:You give us the rights to maintain and distribute your code and we promise
to maintain an open source distribution of anything you contribute.
Package: venv_dependencies
AboutThis app helps to create symbolics links for any module from your
OS python to your current virtual enviroment. This way you don’t
need to do the links by yourself using bash, just use this app.UsageYou use the command:link_venv "module1" "module2"... "moduleN"Example: Enable OpenCV to work in the virtualenv:link_venv.py "cv2"Installpip install venv-dependenciesLicense:This software is distributed using MIT license, see LICENSE file for
more details.
Package: venvdotapp
VEnvDotAppOn a Mac, if you want to access the GUI, or various other mac-specific APIs,
your executable needs to be present in abundle.
This can be an "app bundle" or a "framework bundle".  The System python,
python.org python, Homebrew Python, and pyenv python (with a little
work)
are all so-called "framework builds" which include such a bundle.To build arealbundle, something that you can distribute to someone else,
you probably want to usepy2app.  However, if
you just want topip installa tool that somebody else wrote which happens to
want to present some GUI elements, or you want to develop something of your own
in a virtualenv without setting up the requisitepy2appinfrastructure
(including asetup.py, etc), this might be the tool for you.How to use itIf you're using someone else's code and you just want to make a given
virtualenv bundle-y, justpip install venvdotapp && venvdotapp.For example:$mktempenv...$pipinstallwxpython...$pycrustThis program needs access to the screen. Please run with aFramework build of python, and only when you are logged inon the main display of your Mac.$pipinstallvenvdotapp...$venvdotapp.../.virtualenvs/tmp-4337833f3452981/bin/tmp-4337833f3452981.app$pycrust<A GUI Window Pops Up>If you're writing yourownprogram which requires an app bundle, you don't
need to use the command-line script, just put the following at the very top of
your main script:fromvenvdotappimportrequire_bundlerequire_bundle()Note that this will raise an exception if your base Python is not a framework
build and therefore not capable of displaying a GUI.
Package: venvgit2
pygit2is awesome. pygit2 is hard to install.Installing this package will try to install matched versions of libgit2 and
pygit2 to your activated virtualenv.Requirementscmakepython-devInstallation$ virtualenv venv
$ . venv/bin/activate
(venv)$ pip install venvgit2You can put it in arequirements.txtor whatever, as long as you’re in a
virtualenv you’re set withpiporeasy_install.Usage(venv)$ python
>>> import pygit2Woo hoo if no errors are raised, it is likely that you are set to go!venvgit2doesn’t give you anything except a convenient install of matched
versions oflibgit2andpygit2. Each project has its own excellent”
documentation:libgit2 docspygit2 docsDevelopmentClone this repository$ git clone git@github.com:uniphil/venvgit2.gitGrab the submodules$ git submodule update --initafter the first time, to update submodules it’s just$ git submodule updateWhat’s going onWithoutvenvgit2, you might do this:$ git clone git@github.com:libgit2/libgit2.git
$ git clone git@github.com:libgit2/pygit2.git
$ virtualenv venv
$ . venv/bin/activate
(venv)$ cd libgit2
(venv)$ git checkout v0.20.0
(venv)$ mkdir build && cd build
(venv)$ cmake .. -DCMAKE_INSTALL_PREFIX=$VIRTUAL_ENV
(venv)$ cmake --build . --target install
(venv)$ cd ../../pygit2
(venv)$ git checkout v0.20.2
(venv)$ export LIBGIT2=$VIRTUAL_ENV
(venv)$ export LDFLAGS="-Wl,-rpath='$LIBGIT2/lib',--enable-new-dtags"
(venv)$ python setup.py build
(venv)$ python setup.py installThat should set you up withpygit2ready to roll in your virtual
environment. This command should not fail:(venv)$ python
>> import pygit2
>>It was a big headache for me to getpygit2built and linked correctly, out
of a virtualenv. Also, having to clone full git repos and everything is a pain.venvgit2ships with all the sources for a matched pair oflibgit2andpygit2baked in, so you only have to download what you need, and
installation is automated in thesetup.pyscript. Piece of cake.VersionsReleases ofvenvgit2are matched pairs ofpygit2, andlibgit2. We
increment thepatchnumber (major.minor.patch) each time we release a
new pair (ie., when eithervenvgit2orpygit2update) or when changes
are made tovenvgit2 itself.pygit2hasmore detailsfor choosing compatible
releases, but withvenvgit2,pipinstall...should just work.Licensevenvgit2is provided to the Public Domain. It really doesn’t do much
anyway.The libraries used byvenvgit2have licenses you should be aware of. They
are linked here for quick reference:libgit2:GPLv2 with linking exceptionpygit2:also GPLv2 with linking exception
Package: venvhpl
VirtualEnv Host Package Linkversion number: 1.0.0
author: Mike C. FletcherOverviewLinks Host's Python Library into VirtualenvThis allows you to link a hard-to-compile package into your
virtualenv. Common case is the python-gobject-introspection
library, which is not easily pip installable.Installation / UsageTo install use pip:$ pip install venvhplOr clone the repo:$ git clone https://github.com/mcfletch/venvhpl.git
$ python setup.py installLinking a package from the host python$ source path/to/myenv/bin/activate
(myenv) $ venv-hpl giContributingThis is a trivial project, but if you find something
that needs fixing, please open a pull request.
Package: venvify
venvifyPython package to turn Python installations into venv-like environments that you can activate.Say you have the following python installation:python_env
|- bin
|   |- python3.9
|- include
|- libThen you can venvify it by running the following script:venvify ~/python_envThe result:python_env
|- bin
|   |- python3.9
|   |- python (symlink)
|   |- python3 (symlink)
|   |- activate
|   |- activate.sh
|   |- etc.
|- include
|- libNow you can source theactivatefile to use the environment as you would use a venv:user@laptop: source python_env/bin/activate(python_env)user@laptop: python -m pip install <some_package>To undo the venvifying, simply remove theactivatescripts and the symlinks from thebindirectory.InstallationAll the logic of the package can be found in a single scriptvenvify.py.
The only dependency is thevenvPython standard library package.venvshould be shipped with Python 3, but can be installed withsudo apt install python3-venv.So if you don't want to pip install, you can clone this repo and simply runvenvify.pywith any Python interpreter.However if you don't mind you can:pip install venvifyAnd then run thevenvifycommand.Use case: Blender Python environmentI made this package to make developing python scripts for Blender a bit more convenient.Blender ships with its own Python installation.
But specifying the entire path to the Blender Python executable is tedious.
My initial solution was to add an aliasbpythonto my.bashrc.
This relieved the burden of typing long paths, but another problem remained.Some Python packages come with command line entry points. For example, a package I useBlenderProchas a commandblenderproc.
After installing BlenderProc into the Blender Python installation, there was no way access this command.However, when you install such a package into a virtual environment, its commands are exposed after sourcing the createdactivatefile.
Hence this package, which allowed me to activate the Blender Python environment and use the commands of the installed Python packages.TODOMaybe in the future this package could also ensure pip gets installed into the environment.
Package: venvipy
A GUI for managing multiple Python virtual environmentsIntroductionVenviPyis a graphical user interface for creating or modifing customized
virtual environments quick and easy. It was developed for *NIX systems and
has been tested on various distributions.VenviPyprovides a set of features like a wizard, that guides the user through
the creation process, a table that shows an overview of installed
environments in a specific directory and a collection of context menu
actions like listing detailed information about an environment and much
more.The main menu:The wizard:Output when running pip commands:Key FeaturesCreate virtual environments with any Python version (3.3+)Clone an environment from a requirements fileGenerate requirements from an existing environmentAdd a description to an environmentInstall and update Pip and Wheel with one clickSearch and install packages fromPyPIInstall from requirements filesInstall from local stored project directoriesInstall from a VCS project url(currently git only)Install from local or remote source archivesList detailed information about installed packagesShow dependency tree (usingpipdeptreepackage)Open a project’sPyPIwebsite in your browserPrerequisitsIf you don’t have a Python built from source, you’ll have to runVenviPyusing your operating system’s Python (3.6+). In this case please make sure
that the following packages are installed on your system:python3-pippython3-venvpython3.10-venvInstallationInstalling packages directly into your operating system’s Python is
discouraged. If you want to do it anyway, do it like this:$python3.x-mpipinstallvenvipyThe better way however is to create a virtual environment and installVenviPyinto it:$python3.x-mvenv[your_venv]$source[your_venv]/bin/activateTo install the latest stable version ofVenviPy:$(your_venv)pipinstallvenvipyfor the developement version:$(your_venv)pipinstallgit+https://github.com/sinusphi/venvipy.gitNow you can launchthe main menu via:$(your_venv)venvipyor run the wizard standalone to quickly create and set up an environment:$(your_venv)venvipy-wizardRunning from sourceClone the repository (use the--depthoption):$(your_venv)gitclone--depth50git@github.com:sinusphi/venvipy.gitCd into the repo folder and install the dependencies. On Python 3.6 you will also
need to install thedataclassespackage if you’re not using the providedrequirements.txt:$(your_venv)pipinstall-rrequirements.txtor:$(your_venv)pipinstallPyQt5==5.15.4PyQt5-Qt5==5.15.2PyQt5-sip==12.10.1requestsbeautifoulsoup4Then you canlaunch the main menu:$(your_venv)pythonvenvipy/venvi.pyor run the wizard standalone to quickly create and set up an environment:$(your_venv)pythonvenvipy/wizard.pyContributingContributions are welcomed, as well asPull
requests,bug
reports, andfeature
requests.
Package: venvmgr
venvmgr👀 Manage Python virtual environmentsInstall 💥pipxinstallvenvmgrUsageCreate a venv namedexampleusing venvmgr$vmcreateexampleUse it using venvmgr$vmpython--venvexamplecode.pyThe associations between files and venvs are recorded so that$vmpythoncode.pynow uses theexamplevenv. We might want to install packages in this venv, e.g.,$vmpip--venvexamplescipyWe now might want to check the venvs:$vmls
example
createdat2023-07-0312:07:48.872147
activate:source/home/user/.venvmgr/example/bin/activate
usedby:/home/user/code.pyFor more information, tryvm ls -l.Lastly, we might want to activate this venv$vmactivateexample
Package: venv-modulefile
venv-modulefilevenv-modulefileDescriptionQuick startAvailable commandsDescriptionTool to create Python complient environment from non-pythonic tools in a Python virtual
environment.It is based onEnvironment Moduleto
modify the virtual environment.The package offers several commands to build environment modules activated by the virtual
environnmentQuick startThe following example addsfoo/bar/baztoLD_LIBRARY_PATHwhen the environment is loadedvenvmod-initialize${VIRTUAL_ENV}venvmod-prepend-path${VIRTUAL_ENV}LD_LIBRARY_PATHfoo/bar/bazAvailable commandsThe list of available commands is the following:venvmod-initializeis the first command to call. It is expected before everithing as it upgrades
the virtual environment with modulefile.The following commands modify the modulefile of the virtual environment:venvmod-cmd-append-path/venvmod-cmd-prepend-path: modifies an environment variablevenvmod-cmd-module-load: loads a modulefilevenvmod-cmd-module-use: adds a search path for modulefilevenvmod-cmd-remove-path: removes path from environment variablevenvmod-cmd-setenv: defines an environment variablevenvmod-cmd-set-alias: defines an aliasvenvmod-cmd-source-sh: sources a scriptvenvmod-cmd-read-env: reads modifications to do from environment variable:[NAME]_LD_LIBRARY_PATH,[NAME]_PYTHONPATH,[NAME]_PATH:prependfor each element separated by ':'[NAME]_MODULE_USE:module usefor each element 'module' separated by ' '[NAME]_MODULEFILES:module loadfor each element '/path/' separated by ' '[NAME]_SOURCEFILES:source-shfor each element 'shell script [args...]' separated by ';'[NAME]_EXPORTS:setenvfor each element 'var=value' separated by ' '[NAME]_ALIASES:set-aliasfor each element 'var="value"' separated by ' '[NAME]_REMOVE_PATHS:remove-pathfor each element 'var=value' separated by ' '
where[NAME]is the name of the environment module (case insensitive, "-" and "." are replaced by "_").venvmod-add-appliallows to create sub modulefile.--applioption of the above commands
permit to modify these modulefiles.venvmod-test-import: tests the import of modules given as argumentSee--helpoption for cli description of each command.The sequence to modify the environment respects the sequence of call of the different functions.
Package: venv-pack2
Venv-PackThis is based onvenv-packbut with lots of improvements added bymrmathematica. It has Windows support. Bin/Scripts generated by venv will
work out-of-box.Venv-pack is a command-line tool for packaging virtual environments for distribution. This is useful for deploying code
in a consistent environment.Supports virtual environments created using python3/venv. Venv is part of the python standard library.Install from sourcevenv-pack is available on github and can always be installed from source.pip install git+https://github.com/mrmathematica/venv-pack.gitInstall from pypivenv-pack is available on pypi asvenv-pack2.pip install venv-pack2Command-line UsageOne common use case is packing an environment on one machine to distribute to other machines as part of a deployment
process.On the source machineCreate venv, and then upgrade pip + setuptools first:python -m venv venv
venv\Scripts\activate
python -m pip install -U pip setuptoolsPython generates Windows .exe file such as pip.exe on the fly, so on Windows there is restriction that you want to fix a
version of pip and setuptools at the beginning and stick with it. If needed, re-create new venv from a lock file. Seepip-tools.Install all your python packages, for examplepip install -r requirements.txtPack the current environment into my_env.zipvenv-pack -o env.zipPack an environment located at an explicit path into my_env.zipvenv-pack -p explicit\path\to\env -o env.zipOn the target machineUnpack environment into directorymy_envmd my_env
python -m zipfile -e venv.zip my_env\All features of venv should keep working from my_env folder.