Saravanan666/pypi-org huggingface dataset:
Package: nvcl-kit
nvcl_kit: Access AuScope National Virtual Core Library (NVCL) data servicesIntroductionnvcl_kitis a Python package that provides access to Australia's NVCL (National Virtual Core Library). This is a national database of drill cores that have been analysed by the CSIRO-developed HyLogger hyperspectral core-scanning system. The Hylogger system uses visible and near-infrared, shortwave and thermal infrared reflectance spectroscopy and automatic mineralogical analysis to extract mineralogy data from each drill core.The mineralogy data is maintained by Australia's State and Territory geological surveys and can be accessed via publicly available web services.nvcl_kitcombines these services with OCG WFS borehole data to provide a complete picture of each borehole. It is designed to shield the user from the arcane details of how to establish connections, retrieve and combine datasets.nvcl_kithas two layers of API. The first layer is designed to make it quick and easy to access the borehole mineralogy. The second layer is for more expert users providing access to the full range of available data products.More InformationAuScope NVCL - Australia’s mineralogy databaseHylogger-3How to use itA brief API tutorial ishereExample Jupyter Notebooks are available to try, open thisand go to "notebooks" folderThere is a rough demonstration scripthereAPI documentation can be foundhereLicensenvcl_kitis available underCSIRO Open Source Software Licence Agreement(variation of the BSD / MIT License)CitationIf you use this package in your research please cite:Fazio, Vincent; Mule, Shane; Hunt, Alexander (2023): nvcl_kit: Access AuScope National Virtual Core Library (NVCL) data services. v4. CSIRO. Service Collection.http://hdl.handle.net/102.100.100/480016?index=1
Package: nv-collections
nv-collectionsEnhanced data structures.ChainSequence: chained lists (i.e. group of individual lists that behave as a single flattened list)ObjectDict: dictionary that implements attribute searchStandardKeyMapping: dictionary that standardize keys (e.g. lower case)OrderedSet: a set that preserves order (similar to OrderedDict)Singletons: Singleton metaclass and semantic singletons
Package: nvdlib
Simple NIST NVD API wrapper libraryNVDlibis a Python library that allows you to interface with theNIST National Vulnerability Database(NVD), pull vulnerabilities (CVEs), andCommon Platform Enumeration(CPEs) into easily accessible objects.FeaturesSearch the NVD for CVEs using all parameters allowed by the NVD API (recently updated to utilize version 2 of the API). Including search criteria such as CVE publish and modification date, keywords, severity, score, or CPE name.Search CPE names by keywords, CPE match strings, or modification dates. Then pull the CVE ID's that are relevant to those CPEs.Retrieve details on individual CVEs, their relevant CPE names, and more.Built in rate limiting according toNIST NVD recommendations.Get an API key (https://nvd.nist.gov/developers/request-an-api-key) to allow for a delay argument to be passed. Otherwise it is 6 seconds between requests by default.Install$pipinstallnvdlibDemo>>>importnvdlib>>>r=nvdlib.searchCVE(cveId='CVE-2021-26855')[0]>>>print(r.v31severity+' - '+str(r.v31score))CRITICAL-9.8>>>print(r.descriptions[0].value)MicrosoftExchangeServerRemoteCodeExecutionVulnerabilityThisCVEIDisuniquefromCVE-2021-26412,CVE-2021-26854,CVE-2021-26857,CVE-2021-26858,CVE-2021-27065,CVE-2021-27078.>>>print(r.v31vector)CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:HDevelopmentRun the tests with$pipinstall-e'.[dev]'$pytestDocumentationhttps://nvdlib.comMore informationThis is my first attempt at creating a library while utilizing all my Python experience from classes to functions.For more information on the NIST NVD API for CPE and CVEs, see the documentation here:https://nvd.nist.gov/General/News/New-NVD-CVE-CPE-API-and-SOAP-RetirementThis product uses data from the NVD API but is not endorsed or certified by the NVD.
Package: nvdsw
Data Science WorkbenchBuild processClone the repo, build the docker image for the build environment, e.g.cd nvdss && sh build-docker.sh. Now you can launch your build docker container, e.g.sh run-docker.shTo run the build:sh build.sh none
# if you want to push to the pip test or prod
# sh build.sh test
# sh build.sh prodThe build creates a .whl file, e.g.dist/nvdsw-0.0.382-py3-none-any.whlNow, you can reinstall nvdsw, e.g. do thisoutside of dockerpip3 install --force-reinstall dist/nvdsw-0.0.382-py3-none-any.whlNow you can launch nvdsw:nvdsw
Package: nvexpo
NVEXPO - Non-Volatile EXPOrtnxexpo it's a simple tool to define environment variables on-the-fly and persisting them between shell sessions.DependenciesPython 3.8Dependencies to buildPoetryDependencies to developPoeThePoetRuffMyPyInstallationTo install from the source follow the commands:$poetrybuild
$pipinstalldist/nvexpo*.whlAnd add the follow line to your.bashrcfile:eval"$(nvexpoinitbash)"Basic usageThe usage it's too simple. If you want to create a new env var into the current bash session use the command:$nxweird_variable=101Then, you can close the current terminal or terminate the bash session, and when you start a new one, your env vars will still be there :sparkles:.$echo$weird_variable101Unset variablesTo unset variables you need to use flag--unset:$nxvar1="hello world"$echo$var1helloworld
$nx--unsetvar1
$echo$var1$works!!Why?The main motivation for creating this tool was that in my work I like to have the Git branch I'm working on in$branch, but it's annoying to have to create it every time I restart or close the terminal I was working on.I could add it to.bashrcdirectly, but I would have to do it every time I have to work on a new branch and it wasn't comfortable.So now instead of having to type:branch="super_useful_change"I have to write:nxbranch="super_useful_change"and that's it, no matter how many times I restart, my variable will be there.
Package: nvflare
NVIDIA FLARENVIDIA FLARE(NVIDIAFederatedLearningApplicationRuntimeEnvironment)
is a domain-agnostic, open-source, extensible SDK that allows researchers and data scientists to adapt existing ML/DL workflows to a federated paradigm.
It enables platform developers to build a secure, privacy-preserving offering for a distributed multi-party collaboration.FeaturesFLARE is built on a componentized architecture that allows you to take federated learning workloads
from research and simulation to real-world production deployment.Application FeaturesSupport both deep learning and traditional machine learning algorithms (eg. PyTorch, TensorFlow, Scikit-learn, XGBoost etc.)Support horizontal and vertical federated learningBuilt-in Federated Learning algorithms (e.g., FedAvg, FedProx, FedOpt, Scaffold, Ditto, etc.)Support multiple server and client-controlled training workflows (e.g., scatter & gather, cyclic) and validation workflows (global model evaluation, cross-site validation)Support both data analytics (federated statistics) and machine learning lifecycle managementPrivacy preservation with differential privacy, homomorphic encryption, private set intersection (PSI)From Simulation to Real-WorldFLARE Client API to transition seamlessly from ML/DL to FL with minimal code changesSimulator and POC mode for rapid development and prototypingFully customizable and extensible components with modular designDeployment on cloud and on-premiseDashboard for project management and deploymentSecurity enforcement through federated authorization and privacy policyBuilt-in support for system resiliency and fault toleranceTake a look atNVIDIA FLARE Overviewfor a complete overview, andWhat's Newfor the lastest changes.InstallationTo install thecurrent release:$ python3 -m pip install nvflareGetting StartedYou can quickly get started using theFL simulator.
A detailedgetting startedguide is available in thedocumentation.Examples and notebook tutorials are located atNVFlare/examples.CommunityWe welcome community contributions! Please refer to thecontributing guidelinesfor more details.Ask and answer questions, share ideas, and engage with other community members atNVFlare Discussions.Related Talks and PublicationsTake a look at our growing list oftalks, blogs, and publicationsrelated to NVIDIA FLARE.LicenseNVIDIA FLARE is released under anApache 2.0 license.
Package: nvflare-light
NVIDIAFederatedLearningApplicationRuntimeEnvironmentNVIDIA FLAREis a domain-agnostic, open-source, extensible SDK that
allows researchers and data scientists to adapt existing ML/DL workflows(PyTorch, TensorFlow, Scikit-learn, XGBoost etc.)
to a federated paradigm. It enables platform developers to build a secure, privacy-preserving offering
for a distributed multi-party collaboration.NVIDIA FLAREis built on a componentized architecture that allows you to take federated learning workloads
from research and simulation to real-world production deployment. Key components include:Support both deep learning and traditional machine algorithmsSupport horizontal and vertical federated learningBuilt-in FL algorithms (e.g., FedAvg, FedProx, FedOpt, Scaffold, Ditto )Support multiple training workflows (e.g., scatter & gather, cyclic) and validation workflows (global model evaluation, cross-site validation)Support both data analytics (federated statistics) and machine learning lifecycle managementPrivacy preservation with differential privacy, homomorphic encryptionSecurity enforcement through federated authorization and privacy policyEasily customizable and extensibleDeployment on cloud and on premiseSimulator for rapid development and prototypingDashboard UI for simplified project management and deploymentBuilt-in support for system resiliency and fault toleranceInstallationTo install thecurrent release, you can simply run:$ python3 -m pip install nvflareGetting startedYou can quickly get started using theFL simulator.A detailedgetting startedguide is available in thedocumentation.Examples and notebook tutorials are locatedhere.Related talks and publicationsFor a list of talks, blogs, and publications related to NVIDIA FLARE, seehere.LicenseNVIDIA FLARE has Apache 2.0 license, as found inLICENSEfile.
Package: nvflare-nightly
NVIDIAFederatedLearningApplicationRuntimeEnvironmentNVIDIA FLAREenables researchers to collaborate and build AI models without sharing private data.NVIDIA FLARE is a standalone python library designed to enable federated learning amongst different parties using their local secure protected data for client-side training, at the same time it includes capabilities to coordinate and exchange progressing of results across all sites to achieve better global model while preserving data privacy. The participating clients can be in any part of the world.NVIDIA FLARE builds on a flexible and modular architecture and is abstracted through APIs allowing developers & researchers to customize their implementation of functional learning components in a Federated Learning paradigm.Learn more -NVIDIA FLARE.InstallationTo installthe current release, you can simply run:pipinstallnvflareThird party licenseSee 3rdParty folder for their license files.
Package: nvflops
nvflopsTheNewVersion of theFree-style machine-LearningOpenPlatformSystemKey conceptsAll results from participants are recorded with mandatory metadata, such as parents, creator, creator's role.Blobs of results (the large binary information) are stored in S3 or other dedicate blob storage space.  Their addresses (bucket and object in S3 use case) are stored in the mandatory metadata.Parents and children are many-to-many relationship.  That is, one result can have multiple parents (aggregation operation).  One parents can have multiple results (client's local training).Results can include additional metadata (custom_field) as flat dictionary.  Search can perform against those custom_field.Aggregation style operation as shown in this graph.Package requirementsIn current implementation, vflops requires a blob storage space and only S3 is supported.  Full S3 authentication with AWS IAM credential will be implemented in the future.  For local development and test, you can install [minio][https://min.io/download#/linux).  Minio Python package is required, but it should be easy to replace it with boto3.The backend database can be any SQL database supported by SQLAlchemy.  However, you will need to setup your own database management system.InstallationWe plan to have nvflops wheel package available onPyPi.  You can choose to install via source codes.pip install -e .in nvflops folder (same level as setup.py)
Package: nvhtop
nvhtopA tool for enriching the output ofnvidia-smiforked frompeci1/nvidia-htop.Installpip install .Usageusage: nvhtop [-h] [-l [COMMAND_LENGTH]] [-c]

print GPU utilization with usernames and CPU stats for each GPU-utilizing
process

optional arguments:
  -h, --help            show this help message and exit
  -l [COMMAND_LENGTH], --command-length [COMMAND_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 | nvhtop [-l [length]]is also supported.Example output$ nvhtop -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_classifier.py      |
|    1 11021 cannotte   10765MiB   114   1.5  python3 ./train.py              |
|    2 25544 nevermin   10775MiB   108   2.0  python -m xxxxxxxxxxxxxxxxxxxxx |
+-----------------------------------------------------------------------------+Screenshot with output coloring
Package: nvidia-clara-client
Clara Deploy Python ClientAn intuitive python 3 package to develop applications with NVIDIA Clara Deploy. Utilize the clients within thenvidia_clarapackage to manage jobs, pipelines, payloads, and models. Each client has an associated set of objects which are defined in seperate 'types' modules (also can be found in nvidia_clara). Look at the examples below to learn more on each client to get started!Additional Resources to Learn More on Clara DeployNVIDIA Clara Overview HomepageNVIDIA Clara Deploy SDK User GuideClient PrerequisitesPython 3.6 or higherClara Deploy 0.7.0 or higherPypi Packages NeededGrpcioProtobufGrpcio-Testing (For Running Pytests)Pytest (For Running Pytests)Getting StartedPackage InstallationInstalling fromsource repository$ git clone --recursive git@github.com:NVIDIA/clara-platform-python-client.git
$ cd ./clara-platform-python-client
$ python3 -m pip install requirements.txt
$ python3 -m pip install .Installing directly fromPypi$ python3 -m pip install nvidia-clara-clientClara Client GuidesJobs: Learn to start and manage Clara jobsPipelines: Learn to create and manage Clara pipelinesPayloads: Learn to create, upload, download, and manage Clara payloadsFull  Example(s) Running PipelineSpleen Segmentation PipelineRunning PytestsOnly for developing with source repository$ pip3 install grpcio-testing
$ pip3 install pytest
$ export PYTHONPATH="${PYTHONPATH}:<INSERT PATH TO /clara-platform-python-client>"
$ pytest <INSERT PATH TO /clara-platform-python-client>
Package: nvidia-dali-cuda110
The NVIDIA Data Loading Library (DALI) is a library for data loading and
pre-processing to accelerate deep learning applications. It provides a
collection of highly optimized building blocks for loading and processing
image, video and audio data. It can be used as a portable drop-in replacement
for built in data loaders and data iterators in popular deep learning frameworks.Deep learning applications require complex, multi-stage data processing pipelines
that include loading, decoding, cropping, resizing, and many other augmentations.
These data processing pipelines, which are currently executed on the CPU, have become a
bottleneck, limiting the performance and scalability of training and inference.DALI addresses the problem of the CPU bottleneck by offloading data preprocessing to the
GPU. Additionally, DALI relies on its own execution engine, built to maximize the throughput
of the input pipeline. Features such as prefetching, parallel execution, and batch processing
are handled transparently for the user.In addition, the deep learning frameworks have multiple data pre-processing implementations,
resulting in challenges such as portability of training and inference workflows, and code
maintainability. Data processing pipelines implemented using DALI are portable because they
can easily be retargeted to TensorFlow, PyTorch, MXNet and PaddlePaddle.For more details please check thelatest DALI Documentation.
Package: nvidia-dali-cuda120
The NVIDIA Data Loading Library (DALI) is a library for data loading and
pre-processing to accelerate deep learning applications. It provides a
collection of highly optimized building blocks for loading and processing
image, video and audio data. It can be used as a portable drop-in replacement
for built in data loaders and data iterators in popular deep learning frameworks.Deep learning applications require complex, multi-stage data processing pipelines
that include loading, decoding, cropping, resizing, and many other augmentations.
These data processing pipelines, which are currently executed on the CPU, have become a
bottleneck, limiting the performance and scalability of training and inference.DALI addresses the problem of the CPU bottleneck by offloading data preprocessing to the
GPU. Additionally, DALI relies on its own execution engine, built to maximize the throughput
of the input pipeline. Features such as prefetching, parallel execution, and batch processing
are handled transparently for the user.In addition, the deep learning frameworks have multiple data pre-processing implementations,
resulting in challenges such as portability of training and inference workflows, and code
maintainability. Data processing pipelines implemented using DALI are portable because they
can easily be retargeted to TensorFlow, PyTorch, MXNet and PaddlePaddle.For more details please check thelatest DALI Documentation.
Package: nvidia-dali-tf-plugin-cuda110
The TensorFlow plugin enables usage of DALI with TensorFlow.The NVIDIA Data Loading Library (DALI) is a library for data loading and
pre-processing to accelerate deep learning applications. It provides a
collection of highly optimized building blocks for loading and processing
image, video and audio data. It can be used as a portable drop-in replacement
for built in data loaders and data iterators in popular deep learning frameworks.Deep learning applications require complex, multi-stage data processing pipelines
that include loading, decoding, cropping, resizing, and many other augmentations.
These data processing pipelines, which are currently executed on the CPU, have become a
bottleneck, limiting the performance and scalability of training and inference.DALI addresses the problem of the CPU bottleneck by offloading data preprocessing to the
GPU. Additionally, DALI relies on its own execution engine, built to maximize the throughput
of the input pipeline. Features such as prefetching, parallel execution, and batch processing
are handled transparently for the user.In addition, the deep learning frameworks have multiple data pre-processing implementations,
resulting in challenges such as portability of training and inference workflows, and code
maintainability. Data processing pipelines implemented using DALI are portable because they
can easily be retargeted to TensorFlow, PyTorch, MXNet and PaddlePaddle.For more details please check thelatest DALI Documentation.
Package: nvidia-dali-tf-plugin-cuda120
The TensorFlow plugin enables usage of DALI with TensorFlow.The NVIDIA Data Loading Library (DALI) is a library for data loading and
pre-processing to accelerate deep learning applications. It provides a
collection of highly optimized building blocks for loading and processing
image, video and audio data. It can be used as a portable drop-in replacement
for built in data loaders and data iterators in popular deep learning frameworks.Deep learning applications require complex, multi-stage data processing pipelines
that include loading, decoding, cropping, resizing, and many other augmentations.
These data processing pipelines, which are currently executed on the CPU, have become a
bottleneck, limiting the performance and scalability of training and inference.DALI addresses the problem of the CPU bottleneck by offloading data preprocessing to the
GPU. Additionally, DALI relies on its own execution engine, built to maximize the throughput
of the input pipeline. Features such as prefetching, parallel execution, and batch processing
are handled transparently for the user.In addition, the deep learning frameworks have multiple data pre-processing implementations,
resulting in challenges such as portability of training and inference workflows, and code
maintainability. Data processing pipelines implemented using DALI are portable because they
can easily be retargeted to TensorFlow, PyTorch, MXNet and PaddlePaddle.For more details please check thelatest DALI Documentation.
Package: nvidia-eff
nvidia-effThe NVIDIA Exchange File Format (EFF) was created with the aim of facilitating exchange and interoperability between
different NVIDIA Deep Learning frameworks and tools.A Software License Agreement is included with the product and governs the use of the product. By pulling and using the
NVIDIA Exchange File Format, you accept the terms and conditions of the license. For details please refer to LICENSE.txt.Installation:pip install nvidia-eff
Package: nvidia-eff-tao-encryption
nvidia-effThe NVIDIA Exchange File Format (EFF) was created with the aim of facilitating exchange and interoperability between
different NVIDIA Deep Learning frameworks and tools. The EFF TAO Encryption package contains encryption functions and
tools used by TAO.A Software License Agreement is included with the product and governs the use of the product. By pulling and using the
NVIDIA Exchange File Format, you accept the terms and conditions of the license. For details please refer to LICENSE.txt.Installation - only internal:pip install nvidia-eff-tao-encryption