Saravanan666/pypi-org huggingface dataset:
Package: nvidia-fan-control
Nvidia Fan ControlGUI fan controller for Nvidia GPUWith this app you can set your preferred fan speed for Nvidia GPU (on Linux systems) without to use command line tools.Note:Tested on GTX 460CreditsBased on the work of Sabin Dcosternvidia-fan-control-gui-linuxDisclaimerNVIDIA is a registered trademark of NVIDIA Corporation.Developers and app are not related to NVIDIA.InstallationTo install the app:pip install nvidia_fan_controlorsudo pip install nvidia_fan_controlUsageOpen application through the created menu launcher or from terminalnvidiafancontrolClick on:"Initialize Nvidia Xconfig"If you receive a positive confirmation dialog then click on:"Reboot".
If you receive an error message, you should install thenvidia-smipackage and retryAfterRebootreopen app and set desired speed
Package: nvidia-htop-sk
nvidia-htopA tool for enriching the output ofnvidia-smi.Installpip3 install nvidia-htopYes, this tool has been on PyPi since 2021! Enjoy the super-easy way to install it.Usagenvidia-htop.py [-l [length]]
  print GPU utilization with usernames and CPU stats for each GPU-utilizing process

  -l|--command-length [length]     Print longer part of the commandline. If `length'
                                   is provided, use it as the commandline length,
                                   otherwise print first 100 characters.
  -c|--color                       Colorize the output (green - free GPU, yellow -
                                   moderately used GPU, red - fully used GPU)Note: for backward compatibility,nvidia-smi | nvidia-htop.py [-l [length]]is also supported.Note: running inside a container (docker, singularity, ...),nvidia-smican only see processes running in the container.Example output$ nvidia-htop.py -l
Mon May 21 15:06:35 2018
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 390.25                 Driver Version: 390.25                    |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|===============================+======================+======================|
|   0  GeForce GTX 108...  Off  | 00000000:04:00.0 Off |                  N/A |
| 53%   75C    P2   174W / 250W |  10807MiB / 11178MiB |     97%      Default |
+-------------------------------+----------------------+----------------------+
|   1  GeForce GTX 108...  Off  | 00000000:05:00.0 Off |                  N/A |
| 66%   82C    P2   220W / 250W |  10783MiB / 11178MiB |    100%      Default |
+-------------------------------+----------------------+----------------------+
|   2  GeForce GTX 108...  Off  | 00000000:08:00.0 Off |                  N/A |
| 45%   67C    P2    85W / 250W |  10793MiB / 11178MiB |     51%      Default |
+-------------------------------+----------------------+----------------------+

+-----------------------------------------------------------------------------+
|  GPU   PID     USER    GPU MEM  %MEM  %CPU  COMMAND                                                                                               |
|    0  1032 anonymou   10781MiB   308   3.7  python train_image_classifier.py --train_dir=/mnt/xxxxxxxx/xxxxxxxx/xxxxxxxx/xxxxxxx/xxxxxxxxxxxxxxx  |
|    1 11021 cannotte   10765MiB   114   1.5  python3 ./train.py --flagfile /xxxxxxxx/xxxxxxxx/xxxxxxxx/xxxxxxxxx/xx/xxxxxxxxxxxxxxx                |
|    2 25544 nevermin   10775MiB   108   2.0  python -m xxxxxxxxxxxxxxxxxxxxxxxxxxxxx                                                               |
+-----------------------------------------------------------------------------+Screenshot with output coloring
Package: nvidia-modulus.launch
Modulus Launch (Beta):rotating_light: This repo has been upstreamed toModulusrepositoryModulus Launch is a PyTorch based deep-learning collection of training recipes and tools
for creating physical surrogates.
The goal of this repository is to provide a collection of deep learning training
examples for different phenomena as starting points for academic and industrial applications.
Additional information can be found in theModulus documentation.Modulus PackagesModulus (Beta)Modulus Launch (Beta)Modulus Symbolic (Beta)Modulus Tool-Chain (Beta)InstallationThe PyPi wheel and Dockerfile for this project is being deprecated. The changes
are upstreamed to the mainModulusrepository.
Please refer theModulusrepository andGetting Started Guidefor installation instructions.ContributingFor guidance on making a contribution to Modulus, see thecontributing guidelinesCommunicationGithub Discussions: Discuss architectures, implementations, Physics-ML research, etc.GitHub Issues: Bug reports, feature requests, install issues, etc.Modulus Forum: TheModulus Forumhosts an audience of new to moderate level users and developers for general chat, online
discussions, collaboration, etc.LicenseModulus Launch is provided under the Apache License 2.0, please seeLICENSE.txtfor full license text.
Package: nvidia-nccl-cu11
NCCL (pronounced “Nickel”) is a stand-alone library of standard collective communication routines for GPUs, implementing all-reduce, all-gather, reduce, broadcast, and reduce-scatter. It has been optimized to achieve high bandwidth on any platform using PCIe, NVLink, NVswitch, as well as networking using InfiniBand Verbs or TCP/IP sockets.
Package: nvidia-nccl-cu12
NCCL (pronounced “Nickel”) is a stand-alone library of standard collective communication routines for GPUs, implementing all-reduce, all-gather, reduce, broadcast, and reduce-scatter. It has been optimized to achieve high bandwidth on any platform using PCIe, NVLink, NVswitch, as well as networking using InfiniBand Verbs or TCP/IP sockets.
Package: nvidia-smi
WargOld-Norse: VargDevour everything.This package is a selection of generalised  small utilities classes for many use-cases, a brief description of each follows.A class for easing return of multiple values, implicit handling of args and kwargs and more.A class for executing any 'heavy' function asynchronously storing any results in a bounded queue.
Note: communication and organisation is costly, intended for heavy processing functions and general queuing.
Package: nvimex
Run neovim commands from your shell.Usage:
    nvimex <command>
    nvimex <command> [<args> ...] [-a <address>] [-w]

Arguments:
    <command> The neovim command to run.
    <args>    The args for the command

Options:
    -h, --help               Show this screen
    -a <address> --address=<address>   Sets the neovim instance [default: $NVIM_LISTEN_ADDRESS]
    -w --wipe-current  Wipes current buffer after execution.LICENSEThe MIT License (MIT)Copyright (c) [2015] [Andreas Karlsson]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.
Package: nvlib
# nvlib
nvlib was created so that we can build tools in python to interface with nVentory. As an external source of truth nVentory is used to assist in automating the provisioning process wether it be in house or in the cloud.# Summary
First off nVentory is a Ruby on Rails Datacenter Inventory Manager. nvlib is used to interface with the nventory API.To find out more about setting up the nVentory web service, seehttps://github.com/nventory/nventory# Getting started
To get started install nvlib` pip install nvlib `Create an INI file with settings to connect to your nVentory API` [nv] user: someuser pass: somepass url:http://nventory.domain.com/status: initializing hardware_profile_id: 1 `# Usage` from nvlib import Nventory nventory = Nventory(ini_file) `ChangelogNext Release (TBD)nvlib: Library for querying the nVentory API.1.0feature: Initial revision
Package: nvm
NVMPlenty little helpers.PyPi:https://pypi.org/project/nvm/GitHub:https://github.com/cogsys-io/nvmDocumentation:https://nvm.readthedocs.io(https://nvm.rtfd.io)Developers:https://cogsys.ioFree software: GNU General Public License v3FeaturesPlenty little helpers.CreditsThis package was created withCookiecutterand thecogsys-io/cogsys-io-cookiecutter-pypackageproject template.HistorySeehttps://pypi.org/project/nvm/#history
Package: nvme
pynvmeA pure python implementation of the NVMe spec's data structures, and a plugin
infrastructure for driver specific accessors to devices.Driver PluginsDrive implementations are concrete subclasses ofnvme.Driver. This abstract class
defines the bare minimum behavior necessary to send NVMe commands to a device. In order
for the plugin to be recognized by this module, they must expose the class as asetuptools entry point, or if you are using the Poetry build system,
as aplugin.VersioningThis package follows semantic versioning. Every minor change before 1.0 may contain
breaking changes in addition to feature additions.
Package: nvme-spex
SpexWhat is Spex?Spex is a tool for linting- and generating a structured representation
of the data-structures contained in an NVMe specification document.Please see the full documentation at:https://openmpdk.github.io/SpexFor usersInstalling/Using SpexUsing Nix (Recommended)Given a copy of Nix, the environment will be automatically configured, and is
guaranteed to match the environment in which we develop and for which CI testing
is done.Seehttps://openmpdk.github.io/Spex/setup/nix.htmlfor details.NOTENix works natively on Linux and MacOS, and on Windows via WSL. See the
link above for notes on installing- and using Nix on all 3 platforms.Directly on your machine (Discouraged)make installinstallsSpexfor your userin a separate Python virtual
environment - meaning the dependencies ofSpexare not impacted by other Python
software you install.make uninstallremovesSpex, if installed.Accomplishing this sadly requires a third-party tool,pipx, which we howeverhighly recommend. Please see thepipx sitefor notes on installing this tool.NOTEthat in this case, you will still need Python 3.11 or laterandlibxml2.Using SpexSeehttps://openmpdk.github.io/Spex/user_guide/using_spex.htmlfor
details.For developersSetting up the development environmentNote that targets likebuild,check,formatanddocsall expect to operate
in a properly configured environment.We strongly recommend using Nix directly. It takes care of everything and
ensures that editors can leverage the environment for code-completion and
navigation.
Seehttps://openmpdk.github.io/Spex/setup/nix.htmlTo understand your options, seehttps://openmpdk.github.io/Spex/setup/index.htmlFinally, if you use nix,make devwill put you inside a properly configured
development environment.make dev-docker-build dev-dockerwill do the same, but
within a container.make checkThis target runsallthe tests that our regular CI run would to ensure the software
is in a good state. If you make modifications, please run this before submitting.make formatThis target automatically re-arranges package imports and reformats the code
to comply with our coding standards. Please use this ahead of submitting changes.make docsThis target builds the documentation locally. This is mostly useful when writing
previewing changes to the documentation locally.build|cleanThese targets respectively build and removes a source distribution python package.
You most likely won't need or want this.
Package: nv-nfe
nv.nfeSimple XML parser for reading standard Brazilian digital invoices (NFe)DisclaimersThis library is a "quick and dirt" reader for Brazilian NFe (Nota Fiscal Eletrônica).  The package itself is based on
a simple xml serializer and parser built on top of xmltodict.This has NOT been
tested under for xml vulnerabilitiesand will probably never will, as it was develped as an internal parser for data analysis.DisclaimersTHIS IS UNDOCUMENTED WORK IN PROGRESS. READ THE LICENSE AND USE IT AT YOUR OWN RISK.THIS IS AN ALPHA AND BREAKING CHANGES MAY (AND PROBABLY WILL) OCCUR.
Package: nvpnsxapi
Nicira NVP/NSX Python API and Infrstructure Automation=========================There are two main uses for this python library:(1) **Manage NVP/NSX Infrastructure**Managing, automating, and orchestrating the setup of NVP/NSX componentseleminates repetative CLI commands. Spin up and down environments on the fly,and or manage upgrading new components when you want to upgrade.The Library allows you to remotely setup Hypervisor Nodes, GatewayNodes, Service Nodes etc. (Examples Below)(2) **Python bindings to NVP/NSX REST API**Having python bindings was the first motivation.A) because we developed and were familiar with PythonB) We have been working with OpenStack and it just made sense.With the library you can list networking, attach ports, query nodes etc.(Examples are given in the test/example_api_usage.py)Desclaimer, this is not a full-blown, fully featured API binding. There aremissing binding for NVP API versions as well as NSX versions. If the API call doesnot exist, I welcome any patches.* Note, all api calls have been tested on NVP 3.0-3.2* Note, only partially tested on NSX 4.1.XWhat's New?===========
Package: nvppackage
The README.md file in a Python package typically contains documentation that provides an overview of the package, its features, and how to use it. The file is written in Markdown format, which is a lightweight markup language that allows you to easily format text with headers, links, lists, and other elements.The README.md file is usually one of the first files that a user or developer will see when they visit the package's repository on GitHub or another hosting platform. It can be thought of as the "front page" of the package and serves as a quick reference for what the package does and how to use it.Here are some common sections that you might find in a README.md file for a Python package:Introduction: A brief introduction to the package and its purpose.
Installation: Instructions on how to install the package using pip or another method.
Quickstart: A simple example that demonstrates how to use the package.
Usage: Detailed instructions on how to use the package, including code examples and explanations of its features.
Contributing: Guidelines for how to contribute to the package, such as how to report issues or submit pull requests.
License: Information about the license under which the package is distributed.
The README.md file is an important component of a Python package's documentation, and it's a good idea to keep it up-to-date and informative to help users and developers get started with the package.
Package: nvprof
Tools to help working with nvprof SQLite files, specifically for
profiling scripts to train deep learning models. The files can be big
and thus slow to scp and work with in NVVP. This tool is aimed in
extracting the small bits of important information and make profiling in
NVVP faster.You can remove a big number of unimportant events and take a small time
slice, so that you can shrink the sqlite database a few MBs.Author: Bohumír Zámečníkbohumir.zamecnik@gmail.com,RossumLicense: MITsliced nvprof in NVVPInstallingInstall packagenvprof- for just using it:$ pip install nvprof…or for development:$ pip install -e .Features$ nvprof_tools --help
usage: nvprof_tools [-h] {info,truncate,slice} ...

NVIDIA Profiler tools

positional arguments:
  {info,truncate,slice}

optional arguments:
  -h, --help            show this help message and exit$ nvprof_tools slice --help
usage: nvprof_tools slice [-h] [-s START] [-e END] db_file

positional arguments:
  db_file

optional arguments:
  -h, --help            show this help message and exit
  -s START, --start START
                        start time (sec)
  -e END, --end END     end time (sec)Summary about the fileIt can show:total time (can be used to decide which time slice to take in nvvp)number of events in the tables sorted from highestcompute utilization percentagenumber of GPUs$ nvprof_tools info foo.sqlite
Number of GPUs: 1
Compute utilization: 10.07 %
Total time: 6.659 sec
Total number of events: 516874
Events by table:
CUPTI_ACTIVITY_KIND_RUNTIME : 348080
CUPTI_ACTIVITY_KIND_CONCURRENT_KERNEL : 63792
CUPTI_ACTIVITY_KIND_DRIVER : 48279
CUPTI_ACTIVITY_KIND_SYNCHRONIZATION : 19741
CUPTI_ACTIVITY_KIND_CUDA_EVENT : 17860
CUPTI_ACTIVITY_KIND_MEMCPY : 15974
CUPTI_ACTIVITY_KIND_MEMSET : 2816
CUPTI_ACTIVITY_KIND_OVERHEAD : 309
CUPTI_ACTIVITY_KIND_STREAM : 12
CUPTI_ACTIVITY_KIND_DEVICE_ATTRIBUTE : 8
CUPTI_ACTIVITY_KIND_NAME : 1
CUPTI_ACTIVITY_KIND_CONTEXT : 1
CUPTI_ACTIVITY_KIND_DEVICE : 1In case of multiple GPUs compute utilization is calculated for each
device:Number of GPUs: 4
Compute utilization (mean): 43.04 %
  GPU 0: 42.86 %
  GPU 1: 42.34 %
  GPU 2: 43.42 %
  GPU 3: 43.55 %
Total time: 35.041 sec
Total number of events: 5670557Remove unnecessary eventsTypically 80% of the events are runtime/driver CUDA calls, which are not
essential for profiling deep learning scripts. Let’s remove them.NOTE: It will overwrite the input file.$ nvprof_tools truncate foo.sqliteEg. we shrinked a database from 29 MB to 8 MB.Slice only a small time range# keep only events between 5 and 6 seconds
$ nvprof_tools slice foo.sqlite -s 5.0 -e 6.0More informationMore information
Package: nvs-bootstrap-forms
Django Bootstrap Forms is a Django app that provides enhanced form rendering with Bootstrap styles.InstallationInstall the package using pip:pipinstallnvs-bootstrap-formsAdd ‘bootstrap_forms’ to yourINSTALLED_APPSin the Django settings:INSTALLED_APPS=[# ...'bootstrap_forms',# ...]Include Bootstraps css and js links in your html:<!doctype html><htmllang="en"><head><!-- Your headers goes here --><linkhref="https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/css/bootstrap.min.css"rel="stylesheet"></head><body><!-- Your content goes here --><scriptsrc="https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/js/bootstrap.bundle.min.js"></script></body></html>UsageLoad Bootstrap Forms in your template:{%loadbootstrap_forms_tags%}Use the `bootstrap_form` template tag to render your form:<formmethod="post">{%csrf_token%}{%bootstrap_formform%}<buttontype="submit">Submit</button></form>This will render the form with Bootstrap styles.Customization:You can customize the rendering of individual fields by using thefield_orderand other attributes in your form fields.For advanced customization, you can extend the providedBootstrapFormRendererNodeclass in thebootstrap_forms.templatetags.bootstrap_forms_tagsmodule.ContributingFeel free to contribute by opening issues or submitting pull requests. Please read theContributing Guidelinesfor more details.LicenseThis project is licensed under the MIT License - see theLICENSEfile for details.
Package: nvshim
NVM ShimAutomagically use the correct version of node withnvm execfunctionality.No morenvm useThis will use existing.nvmrcfile, falling back to thenvm alias defaultversion if no config detected.InstallationPippipinstallnvshimGithubpipinstallgit+git://github.com/iamogbz/nvshim.gitConfigurationReads all configuration from the environment.NVM_DIRRelies on nvm being installed and configured correctly.NVSHIM_AUTO_INSTALLSet to1ortrueto auto install specified version of node if not installed bynvm.NVSHIM_VERBOSESet to1ortrueto show more information on the shimmed node process.Otherwise set to0orfalseor nothing.CaveatsTo allow thenvshiminstallednodeshim work in all directories, you'll need to stop sourcingnvm.shin your shell rc i.e.bash_profile,zshrcetc.Just comment out thesource /Users/me/.nvm/nvm.shin your shell startup script. This is optional and preventsnvmfrom taking control of your shell path on launch.ContributionAll forms of contribution welcome, please seeguide.makeinstallmaketests
Package: nvsl-fiddle
Fiddle: A Tool For Studying Small Compiled rogramsFiddle is a tool for studying the compilation and execution of smallish programs written in C or
C++.  If you want to know what the compiler does to your code and why your code is slow, Fiddle can help.It makes it easy to ask and answer interesting questions about what happens to
programs as they go from source code to running program.  Fiddle can run on its
own, but it is built to work withJupyter Notebook/Jupyter
Labto support interactive exploration.It's features include:Support for compiled languages like C and C++.Control Flow Graph (CFG)generation from compiled code.Easy support for varying build-time and run-time paremeters.Easy, unified parameter and data gathering across building and running code.Works great withPandasandJupyter Notebook/Lab.The best way to learn about Fiddle is to try it.  You canrun the
examples(this can take a while to load).Or run it locally with Docker:docker run -it --publish published=8888,target=8888 stevenjswanson/fiddle:latest jupyter lab --LabApp.token=''and then visithttp://localhost:8888/lab/tree/README.ipynb.You can also readthe documentation.ExamplesWhat Does aforloop look like in assembly?>>>fromfiddleimport*>>>sample=code(r"""...    extern "C"...    int loop() {...    int sum = 0;...	   for(int i = 0; i < 10; i++) {... 		sum += i;...    }...	   return sum;... }... """)>>>asm=build(sample)[0].asm("loop")>>>print(asm)# doctest: +SKIPloop:.LFB0:.cfi_startprocendbr64pushq%rbp.cfi_def_cfa_offset16.cfi_offset6,-16movq%rsp,%rbp.cfi_def_cfa_register6movl$0,-8(%rbp)movl$0,-4(%rbp).L3:cmpl$9,-4(%rbp)jg.L2movl-4(%rbp),%eaxaddl%eax,-8(%rbp)addl$1,-4(%rbp)jmp.L3.L2:movl-8(%rbp),%eaxpopq%rbp.cfi_def_cfa7,8ret.cfi_endprocOr, if you prefer a CFG:>>> build(sample)[0].cfg("loop", "readme_loop.png") 
'readme_loop.png'What Does-O3Do To That Loop?>>>asm=build(sample,build_parameters=dict(OPTIMIZE="-O3"))[0].asm("loop")>>>print(asm)# doctest: +SKIPloop:.LFB0:.cfi_startprocendbr64movl$45,%eaxret.cfi_endprocLocal InstallationFiddle depends on some system packages and python'swheel.  Setup a virtual environment:python -m venv fiddle-venvBecome root, so you can install the systetm packages withapt-getwithsudo bash
. fiddle-venv/bin/activate	
make install-prereqs
exitInstall fiddle:. fiddle-venv/bin/activate
pip install .Run the tests:make testCommon ProblemsFiddle needsLD_LIBRARY_PATHset properly to work, and it can't set it itself reliably.  If you getOSError: libfiddle.so: cannot open shared object file: No such file or directoryYou can updateLD_LIBRARY_PATHwith:$(set-fiddle-ld-path)Saving Your WorkIf you want to save changes you make to any of the examples, you'll need to run docker something like this:docker run -it --publish published=8888,target=8888 --mount type=bind,source=$HOME,dst=/home/jovyan -w /home/jovyan/fiddle_work/fiddle  stevenjswanson/fiddle:latest  jupyter lab --LabApp.token=''
Package: nvsmi
nvsmiA (user-)friendly wrapper tonvidia-smi.It can be used to filter the GPUs based on resource usage (e.g. to choose the least utilized GPU on a multi-GPU system).UsageCLInvsmi --help
nvsmi ls --help
nvsmi ps --helpAs a libraryimport nvsmi

nvsmi.get_gpus()
nvsmi.get_available_gpus()
nvsmi.get_gpu_processes()PrerequisitesAn nvidia GPUnvidia-smiPython 2.7 or 3.6+InstallationpipxThe recommended installation method ispipx.
More specifically, you can installnvsmifor your user with:pipxinstallnvsmiThe above command will create a virtual environment in~/.local/pipx/venvs/nvsmiand
add thenvsmiexecutable in~/.local/bin.pipAlternatively you can use good oldpipbut this is more fragile thanpipx:pip install --user nvsmi