Saravanan666/pypi-org huggingface dataset:
Package: nimcli
Nimble Command Line (CLI) ToolingIt provides cli tools for miners, validators and network operators.DevelopmentVirtual Env# create env and activatemakeenvsource./nbenv/bin/activate# install dependenciesbrewinstallpython@3.11
brewlinkpython@3.11
python3-mpipinstall--upgradepip
python3-mpipinstall-rrequirements.txt
python3-mpipinstall-e./# formatblack*py
blackcommands/*py# clean after code devdeactivate
makecleanInstall# installer option$/bin/bash-c"$(curl-fsSLhttps://raw.githubusercontent.com/nimble-technology/nimble-cli/main/scripts/install.sh)"# pip install option$pip3installnimcli# test install from command line# usage: nimcli <command> <command args># commands:#   subnets (s, subnet) - Commands for managing and viewing subnetworks.#   root (r, roots) - Commands for managing and viewing the root network.#   wallet (w, wallets) - Commands for managing and viewing wallets.#   stake (st, stakes) - Commands for staking and removing stake from hotkey accounts.#   sudo (su, sudos) - Commands for subnet management.#   legacy (l) - Miscellaneous commands.# test install$nimcli--helpWallet CLI as an ExampleEach wallet has a coldkey. Each coldkey may contain multiple hotkeys and each hotkey belong to a single coldkey. Coldkeys are for secure fund management like transfer, staking, and fund storage. Hotkeys are for all online operations like signing, mining and validating.# use nimcli with wallet subcommand or alias w.$nimcliwalletnew_coldkey
$nimcliwalletnew_hotkey

$nimcliwalletregen_coldkey--mnemonic*************************************************# keys are available here: ~/.nimble/wallets$nimcliwalletlist# more commands$nimcliwalletlist
$nimcliwallettransferRelease (Core Contributors Only)Run the following command to create dist folderpythonsetup.pysdistThen use the following command to publish to pypitwineuploaddist/nim-cli-{version}.tar.gz
Package: ni-measurementlink-generator
MeasurementLink™ Code Generator for PythonIntroductionMeasurementLink Code Generator for Python (ni-measurementlink-generator) is a
tool for generating reusable measurement plug-ins using gRPC services.For installation and usage, seeMeasurementLink Support for Python (ni-measurementlink-service).DependenciesPython >= 3.8(3.9 recommended)mako >= 1.2.1, < 2.xclick >= 8.1.3
Package: nimfa
NimfaNimfa is a Python module that implements many algorithms for nonnegative matrix factorization. Nimfa is distributed under the BSD license.The project was started in 2011 by Marinka Zitnik as a Google Summer of Code project, and since
then many volunteers have contributed. See AUTHORS file for a complete list of contributors.It is currently maintained by a team of volunteers.Important linksOfficial source code repo:https://github.com/marinkaz/nimfaHTML documentation (stable release):http://ai.stanford.edu/~marinka/nimfaDownload releases:http://github.com/marinkaz/nimfa/releasesIssue tracker:http://github.com/marinkaz/nimfa/issuesDependenciesNimfa is tested to work under Python 2.7 and Python 3.4.The required dependencies to build the software are NumPy >= 1.7.0,
SciPy >= 0.12.0.For running the examples Matplotlib >= 1.1.1 is required.InstallThis package uses setuptools, which is a common way of installing
python modules. To install in your home directory, use:python setup.py install --userTo install for all users on Unix/Linux:sudo python setup.py installFor more detailed installation instructions,
see the web pagehttp://ai.stanford.edu/~marinka/nimfaUseRun alternating least squares nonnegative matrix factorization with projected gradients and Random Vcol initialization algorithm on medulloblastoma gene expression data::>>> import nimfa
>>> V = nimfa.examples.medulloblastoma.read(normalize=True)
>>> lsnmf = nimfa.Lsnmf(V, seed='random_vcol', rank=50, max_iter=100)
>>> lsnmf_fit = lsnmf()
>>> print('Rss: %5.4f' % lsnmf_fit.fit.rss())
Rss: 0.2668
>>> print('Evar: %5.4f' % lsnmf_fit.fit.evar())
Evar: 0.9997
>>> print('K-L divergence: %5.4f' % lsnmf_fit.distance(metric='kl'))
K-L divergence: 38.8744
>>> print('Sparseness, W: %5.4f, H: %5.4f' % lsnmf_fit.fit.sparseness())
Sparseness, W: 0.7297, H: 0.8796Cite@article{Zitnik2012,
  title     = {Nimfa: A Python Library for Nonnegative Matrix Factorization},
  author    = {Zitnik, Marinka and Zupan, Blaz},
  journal   = {Journal of Machine Learning Research},
  volume    = {13},
  pages     = {849-853},
  year      = {2012}
}
Package: nimformat
# nimformatThe nimformat library is the result of an experiment in using the excellent nimpy module, for the awesome Nim programming language, to create a test library, for Python. The goal was to learn some about Nim, nimpy, creating native Python modules, and to see what, if any, speed boosts could be realized.The `nim_sub()` function is a rudimentary implementation of string substitution in a similar way to how Python accepts a dictionary for its `string.format()`.The Nim native Python library can be built by issuing the following command.`nim c --threads:on --app:lib --out:nimformat.pyd --tlsEmulation:off nimformat.nim`NOTE: This was done using the latest development version of Nim, which is 0.19.9 at the time of this writing.Simple benchmarks with Python's `timeit` module yield the following results. See `test_nimformat.py` for more details.```Pure Python time                       : 1.7126781147680623e-05Pure Python [no locals()] time         : 1.8929600215857533e-05Nim dylib time                         : 0.2829040771053697Nim dylib [no locals()] time           : 0.0016501803870713205Nim dylib sub_multi time               : 0.29930432216857517Nim dylib sub_multi [no locals()] time : 0.0007848272343464746```Example 1:```import nimformatvariable1 = 'string'variable2 = 'contains'dictSub = dict(locals())dictSub = {str(key): str(dictSub[key]) for key in dictSub.keys() if '__' not in str(key)}strWithSubstitutions = """This is a {variable1} which spansmultiple lines and {variable2} multiplesubstitutions."""strSubstituted = nimformat.nim_sub(strWithSubstitutions, dictSub)```Example 2:```import nimformatdictSub = {'variable1': 'string','variable2': 'contains'}strWithSubstitutions = """This is a {variable1} which spansmultiple lines and {variable2} multiplesubstitutions."""strSubstituted = nimformat.nim_sub(strWithSubstitutions, dictSub)```
Package: nimgame
“””Play the Game of Nim, interactively or using the APIAboutThis package implements the game called Nim. The game can be played
interactively in the CLI, or in a web browser. You can install this package and
play the game. Easy:> pip install nimgame
> nimgameYou can actuallyTryIt, before installing anything.Those, who are more of the developer types, can use the API, after installing
the package. The game can then be embedded in other applications and played
from any other kind of a GUI.For mathematicians/statisticians, it can also be used for creating statistics
by running multiple games. If you knowcombinatorial game theoryterms likesequential game,perfect information,impartial game,Sprague–Grundy theorem, this API can be useful for you.Game RulesFor the general description of the Nim and similar games, see theWikipedia page.The game is played with coins arranged in heaps. There may be any number of
heaps and any number of coins in a heap.Two palyers play the game. The computer can be a player. Players take turns. In
each turn, a player takes coins from one (only 1) heap. There is no upper limit
of taken coins (but the heap size).  At least 1 coin must be taken.There are 2 types of the game:the “normal” game is where the player, who takes the last coin, winsthe “misère” game is where the player, who has to take the last coin, losesAPI UsageFirst, the heaps are to be set up. The starting heaps then can be analysed and
the starting player selected. If it is the Computer, it automatically does the
1stmove. Then the Player is to do the next move, then the Computer
moves, and so on. When no more coins left, the game ends.importnimgamenim=nimgame.Nim(error_rate=10)# Make the Computer do 10% errorsnim.setup_heaps()# Create heaps randomlynim.set_start(myturn=True)# Indicate that the Player wants to startnim.do_move(nim.Move('b',4))# From heap 'B', remove 4 coins...ifnim.game_end():exit(0)
Package: nim-install
This package can be used to install the nim compiler in a virtualenv:virtualenv /your/venv
source /your/venv/bin/activate
pip install nim-install
nim_install
nim --versioninstalls nim version 1.2.6, nimble, nimgrep and nimsuggestIf you want to install a different version run e.g.:nim_install 1.0.8The compilation of nim is executed in parallel. Total installation time is about
40 seconds on my machine (including download time).
Package: nimiqclient
Nimiq Python ClientPython implementation of the Nimiq RPC client specs.UsageTo get started sending requests to a Nimiq node, we create aNimiqClientobject.importnimiqclientclient=NimiqClient(scheme="http",user="luna",password="moon",host="127.0.0.1",port=8648)# make rpc call to get current block numberblockNumber=client.blockNumber()print(blockNumber)Note: When noconfigobject is passed in the initialization it will use the default values in the Nimiq node.APIThe complete API documentation is availablehere.Check out the originalNimiq RPC specsfor the behind-the-scenes RPC calls.InstallationUsing PIPpipinstallnimiqclientOr clone the repository and install the package from sourcegitclonehttps://github.com/nimiq-community/python-clientcdpython-client
pythonsetup.pyinstallBuildClone the repo and install itgitclonehttps://github.com/nimiq-community/python-clientcdpython-client
pythonsetup.pyinstallAll done, happy coding!TestYou need a start a Testnet Nimiq node:nodejsindex.js--protocol=dumb--type=full--network=test--rpcTests are stored in the/testsfolder and can be run from the command line like this:python-munittestdiscover-vDocumentationThe documentation is generated automatically withSphinx.From the repository root directory install the development dependency requirements:pipinstall-rrequirements-dev.txtThen from the/docsdirectory run Sphinx via themakecommand:cddocs
makehtmlAdd a blank file in the/docsfolder with the name.nojekyllfor the documentation hosted on GitHub Pages:touch.nojekyllContributionsThis implementation was originally contributed byrraallvv.Bug reports and pull requests are welcome! Please refer to theissue trackerfor ideas.LicenseApache 2.0
Package: nimlib
Nimble LibrariesIt provides common libraries reusable by miners, validators and network operators.DevelopmentVirtual Env# create env & activatemakeenvsource./nbenv/bin/activate# install dependenciespython3-mpipinstall-e./# clean envdeactivate
makecleanInstall# pip install option$pip3installnimlib# test install from pythonimportnimlib# cuda dependency for cubit install - python 3.10 examplepipinstallhttps://github.com/nimble-technology/cubit/releases/download/v1.1.2/cubit-1.1.2-cp310-cp310-linux_x86_64.whlWalletEach wallet has a coldkey. Each coldkey may contain multiple hotkeys and each hotkey belong to a single coldkey. Coldkeys are for secure fund management like transfer, staking, and fund storage. Hotkeys are for all online operations like signing, mining and validating.# wallet creation in pythonimportnimlibwallet=nimlib.wallet()wallet.create_new_coldkey()wallet.create_new_hotkey()# Sign data with the keypair.wallet.coldkey.sign(data)Release (Core Contributors Only)Run the following command to create dist folderpythonsetup.pysdistThen use the following command to publish to pypitwineuploaddist/nimlib-{version}.tar.gz
Package: nimodinst
Overall Statusmaster branch statusGitHub statusInfoPython bindings for NI Modular Instrument drivers. SeeGitHubfor the latest source.AuthorNIAboutThenimodinstmodule provides a Python API for NI-ModInst. The code is maintained in the Open Source repository fornimi-python.Support Policynimodinstsupports all the Operating Systems supported by NI-ModInst.It followsPython Software Foundationsupport policy for different versions of CPython.NI-ModInst Python API StatusNI-ModInst (nimodinst)Driver Version Tested Against2023 Q2PyPI VersionSupported Python VersionDocumentationOpen IssuesOpen Pull RequestsInstallationAs a prerequisite to using thenimodinstmodule, you must install the NI-ModInst runtime on your system. Visitni.com/downloadsto download the driver runtime for your devices.The nimi-python modules (i.e. forNI-ModInst) can be installed withpip:$ python -m pip install nimodinst~=1.4.7ContributingWe welcome contributions! You can clone the project repository, build it, and install it byfollowing these instructions.UsageThe following is a basic example of using thenimodinstmodule to retrieve information on all High Speed Digitizers currently in the system.importnimodinstwithnimodinst.Session("niscope")assession:fordeviceinsession:print("{: >20}{: >15}{: >10}".format(device.device_name,device.device_model,device.serial_number))Other usage examples can be found on GitHub.Support / FeedbackFor support specific to the Python API, follow the processs inBugs / Feature Requests.
For support with hardware, the driver runtime or any other questions not specific to the Python API, please visitNI Community Forums.Bugs / Feature RequestsTo report a bug or submit a feature request specific to Python API, please use theGitHub issues page.Fill in the issue template as completely as possible and we will respond as soon
as we can.DocumentationDocumentation is availablehere.Licensenimi-pythonis licensed under an MIT-style license (see
LICENSE).
Other incorporated projects may be licensed under different licenses. All
licenses allow for non-commercial and commercial use.gRPC FeaturesFor driver APIs that support it, passing a GrpcSessionOptions instance as a parameter to Session.__init__() is
subject to the NI General Purpose EULA (see NILICENSE).
Package: nimoy-framework
A testing and specification framework for Python 3, heavily inspired by the amazingSpockFramework.FeaturesBased onunittest, so minimal dependencies are required and specifications are recognized by IDEs and report analyzers.Reduction of boilerplate code.Write detailed specifications with clear distinction.Auto discovery of specifications.Write data-driven specifications.Pretty mock behavior assertion.See fancy detailed assertion failure reports.LicenseApache License 2.0In memory of Leonard Nimoy 1931-2015
Package: nimp
Nested Imports (Nimp)Allows nested imports, a la Java. Nimp installs a harmless meta import-hook that
adds support fornested packages, i.e., multiple packages that “live” under a
common namespace. This is the idiom in Java, where you have packages likecom.foo.bar.spamandcom.foo.bar.eggs, as well as in Haskell and several
other languages. Nimp basically allows packages to “inject” themselves into
shared namespaces.Compatible with Python 2.3-2.7 and 3.0 and up.You can read more aboutnimpand__lazy__on myblog.Usageimport nimp
nimp.install()You can add these two lines to yoursite.pyscript, so you’ll get Nimp
out of the box.BenefitsAllows for distributing “plug-in” packages independently: consider a project
liketwisted, made of several add-on packages (but without hackingdistutilstoo much).A project may depend on packageX.Ywithout having to depend onX.These nested-packages can be found anywhere on your python path (they don’t have
to be located in the same directory)A small (less than 100 LoC) standalone module that does all the magic for you –
no third-party cooperation required.Notedistutilshas problems with directory names that contain dots (as incom.ibm.storage), so Nimp supportseither dots or hyphens(e.g.,com-ibm-storage). This allows you to distribute your package nicely, using
commonplace distribution mechanisms.The recommended way is to use hyphens, but you may continue to use dots,
as was the case in previous versions. However,never mix dots and hyphens(e.g.,com.ibm-storage) – it will not work.Example LayoutConsider the following directory structure, somewhere on your python path
(say,site-packages):site-packages/

  com-ibm-storage/
    files...

  com-ibm-storage-plugins/
    files...

  com-ibm-pythontools/
    files...After callingnimp.install(), the following imports will work as expected:import com                              # a namespace package (empty)
import com.ibm                          # a namespace package (empty)
import com.ibm.pythontools              # a real package
com.ibm.pythontools.myfunc(1,2,3)

# and of course `from x import y` works too
from com.ibm.storage import ScsiDisk

# note how the `plugins` package is "injected" into `storage`
from com.ibm.storage.plugins import MySQLPlugin
Package: nimpa
NIMPA is a stand-alone Python sub-package ofNiftyPET, dedicated to high-throughput processing and analysis of brain images, particularly those, which are acquired using positron emission tomography (PET) and magnetic resonance (MR).  Although, it is an essential part of theNiftyPETpackage for seamless PET image reconstruction, NIMPA is equally well suited for independent image processing, including image trimming, upsampling and partial volume correction (PVC).Trimming is performed in order to reduce the unused image voxels in brain imaging, when using whole body PET scanners, for which only some part of the field of view (FOV) is used.The upsampling is needed for more accurate extraction (sampling) of PET data using regions of interest (ROI), obtained using parcellation of the corresponding T1w MR image, usually of higher image resolution.PVC is needed to correct for the spill-in and spill-out of PET signal from defined ROIs (specific for any given application).Documentation with installation manual and tutorials:https://niftypet.readthedocs.io/Quick InstallNote that it’s recommended (but not required) to useconda.# cross-platform installcondainstall-cconda-forgepython=3\ipykernelnumpyscipyscikit-imagematplotlibipywidgetsdipynibabelpydicompipinstall"nimpa>=2"For optionaldcm2niix(image conversion from DICOM to NIfTI) and/orniftyreg(image registration) support, simply install them separately (pip install dcm2niix niftyreg).External CMake ProjectsThe raw C/CUDA libraries may be included in external projects usingcmake.
Simply build the project and usefind_package(NiftyPETnimpa).# print installation directory (after `pip install nimpa`)...python-c"from niftypet.nimpa import cmake_prefix; print(cmake_prefix)"# ... or build & install directly with cmakemkdirbuild&&cdbuildcmake../niftypet&&cmake--build.&&cmake--install.--prefix/my/install/dirAt this point any external project may include NIMPA as follows
(Once setting-DCMAKE_PREFIX_DIR=<installationprefix from above>):cmake_minimum_required(VERSION3.3FATAL_ERROR)project(myproj)find_package(NiftyPETnimpaCOMPONENTSimprocREQUIRED)add_executable(myexe...)target_link_libraries(myexePRIVATENiftyPET::improc)LicenceCopyright 2018-21Pawel J. Markiewicz@ University College LondonCasper O. da Costa-Luis@ University College London/King’s College LondonContributors
Package: nimport
Nimportuses github actiontwine-uploadRequirementsNeedsgitto be installed forgithubprovider to workUse!pip install --upgrade nimport
%load_ext nimportExamplesGet a file from public repo and navigate to that file%nimport container="yaananth/hack-sample-note2" path="one.ipynb" provider="github" providerOptions={} navigate="trueOrAnythingHere"Get a file from public repo and display a link to that file%nimport container="yaananth/hack-sample-note2" path="one.ipynb" provider="github" providerOptions={}Get a file from private repo and navigate to that file%nimport container="yaananth/hack-sample-note2" path="one.ipynb" provider="github" providerOptions={{"token":"PATTOKENHERE"}} navigate="trueOrAnythingHere"Clone a public repo and navigate to the boot strap fileNeedsgitto be accessible%nimport container="yaananth/pipeline-delays" path="delays.ipynb" provider="github" providerOptions={"clone":"true"}Parameterize notebook from URLfrom nimport.utils import open_nb, load_params
params = load_params(currentUrl)
open_nb("pipeline-delays/delays.ipynb", params, redirect=True)Get URL from browser into python (Javascript to python communication in nteract)clientData = {}
def callback(x):
    global clientData
    clientData = x
parse_client_data(callback)
print(clientData)DevelopPackagepipinstall-rrequirements.txt
pythonsetup.pysdistPublishpipinstalltwine
twineuploaddist/*TestLoadsample.ipynbResourceshttps://packaging.python.org/guides/using-testpypi/https://libraries.io/pypi/twinehttps://test.pypi.org/manage/projects/https://pygithub.readthedocs.io/en/latest/introduction.html
Package: nimrodel
NimrodelA simple Bottle.py-wrapper to provide HTTP API access to any python object.RequirementsPython 3.5 or higherQuick StartInstall withpip install nimrodelCreate your API withfromnimrodelimportAPImyapi=API()You may optionally pass a port number withport=42, a path withpath="api"and whether you want to serve on IPv4 (IPv6=False).
You can also give the API object an existing bottle server (server=bottleobject), in which case your API will be served on the existing server. It is heavily recommended to also pass a path variable to separate API from regular routing of your server.
You may also pass a custom function withparsedoc=yourfunctionthat takes your method as input and returns a dictionary with the valuesdescfor the function description,paramsfor a dictionary of parameter names mapped to a dictionary andreturnsfor a dictionary of the return value. Both return and param dictionaries can have the keystypeanddescfor data type and description respectively. By default nimrodel will attempt to parse your docstring according to the reST standard (Sphinx).Then make any class accessible with a decorator.@myapi.apiclass("group")classGroup:def__init__(self,name,apipath,songs):# some stuffself.__apiname__=apipathAny instance of that class is now accessible via the combination of class path and its individual path. Now just decorate the methods. All its arguments can be passed via URI query arguments.@myapi.get("songs")defget_songs(self,member):return{"songs":[s["title"]forsinself.songsifmemberins["performers"]]}Now create an object and make sure it has an__apiname__attribute:e=Group("Exid","exid",exidsongs)Then you can access its methods with simple HTTP calls like/group/exid/songs?member=Junghwa.There is also an integrated graphical API explorer under/api_explorer.Nimrodel also allows you to create a simple function-based API with the classEAPI.For more in-depth exploration of the possibilities, refer to the fileexample.pyincluded in the repository.
Package: nimrod-reader-aricooperdavis
NIMROD_ReaderA python 3.x script to read Met Office composite radar scenes in the NIMROD format.This should be able to read all three types of composite scene (UK @ 1km, UK @ 5km and Europe @ 5km) but the geotiff creation part of the library has only been tested with UK @ 1km data.If you are a CEDA user then you can find NIMROD data data in: /badc/ukmo-nimrod/Requires: Numpy, gdal
Package: nimses-adimate
Nimses Adimate (Nimses Ad Automate)This script automatically clicks ads in the Nimses Android app.Simply launch thenimses-adimatemodule (__main__.pyfile) and follow the instructions.
They will guide you through connecting your Android Smartphone to your PC.First it needs to be connected through USB to switch to networked mode and then use WiFi
for the rest of the process.RequirementsAn Android device, preferably with a modern version of AndroidUSB Debugging enabled on that deviceRecommendationsThis script and the Nimses app itself consume quite a bit of power,
just keep your phone charging the whole time and don't worry about the power consumption.You should also enable "Stay awake" to make sure your device doesn't lock itself.RunningIf you are just interested in running this application, run the following commands
depending on the way you like to use this application.PyPipip install nimses-adimate
python -m nimses-adimateGitgit clone https://github.com/GiantTreeLP/nimses-adimate
pip install -r requirements.txt
python -m nimses-adimateDependenciesThis script uses the following libraries:adbutilsopencv-pythonnumpyBinary dependenciesThis script requires the Android Debugging Bridge (ADB).
The Windows binaries are bundled with this repository.
If you are using a different operating system, make sure theadbexecutable is in the executable path.