Saravanan666/pypi-org huggingface dataset:
Package: nipy
NIPYNeuroimaging tools for Python.The aim of NIPY is to produce a platform-independent Python environment for
the analysis of functional brain imaging data using an open development model.In NIPY we aim to:Provide an open source, mixed language scientific programming environment
suitable for rapid development.Create software components in this environment to make it easy to develop
tools for MRI, EEG, PET and other modalities.Create and maintain a wide base of developers to contribute to this
platform.To maintain and develop this framework as a single, easily installable
bundle.NIPY is the work of many people. We list the main authors in the fileAUTHORin the NIPY distribution, and other contributions inTHANKS.WebsiteCurrent information can always be found at theNIPY project website.Mailing ListsFor questions on how to use nipy or on making code contributions, please see
theneuroimagingmailing list:https://mail.python.org/mailman/listinfo/neuroimagingPlease report bugs at github issues:https://github.com/nipy/nipy/issuesYou can see the list of current proposed changes at:https://github.com/nipy/nipy/pullsCodeYou can find our sources and single-click downloads:Main repositoryon Github;Documentationfor all releases and current development tree;Download thecurrent development versionas a tar/zip file;Downloads of allavailable releases.TestsTo run nipy’s tests, you will need to install thepytestPython testing
package:pip install pytestThen:pytest nipyYou can run the doctests along with the other tests with:pip install pytest-doctestplusThen:pytest --doctest-plus nipyInstallationSee the latestinstallation instructions.LicenseWe use the 3-clause BSD license; the full license is in the fileLICENSEin
the nipy distribution.
Package: nipype
Current neuroimaging software offer users an incredible opportunity to
analyze data using a variety of different algorithms. However, this has
resulted in a heterogeneous collection of specialized applications
without transparent interoperability or a uniform operating interface.Nipype, an open-source, community-developed initiative under the
umbrella ofNiPy, is a Python project that provides a
uniform interface to existing neuroimaging software and facilitates interaction
between these packages within a single workflow. Nipype provides an environment
that encourages interactive exploration of algorithms from different
packages (e.g., AFNI, ANTS, BRAINS, BrainSuite, Camino, FreeSurfer, FSL, MNE,
MRtrix, MNE, Nipy, Slicer, SPM), eases the design of workflows within and
between packages, and reduces the learning curve necessary to use different packages. Nipype is creating a collaborative platform for neuroimaging software development in a high-level language and addressing limitations of existing pipeline systems.Nipypeallows you to:easily interact with tools from different software packagescombine processing steps from different software packagesdevelop new workflows faster by reusing common steps from old onesprocess data faster by running it in parallel on many cores/machinesmake your research easily reproducibleshare your processing workflows with the community
Package: ni-python-styleguide
NI Python Style GuideWelcome to NI's internal and external Python conventions and enforcement tooling.Written ConventionsOur written conventions can be found athttps://ni.github.io/python-styleguide/.Their source is indocs/Coding-Conventions.md.NOTE: Using the GitHub Pages link is preferable to a GitHub/bloblink.Enforcement toolingAs a tool,ni-python-styleguideis installed like any other script:pipinstallni-python-styleguideLintingTo lint, just run thelintsubcommand (from within the project root, or lower):ni-python-styleguidelint# orni-python-styleguidelint./dir/# orni-python-styleguidelintmodule.pyThe rules enforced are all rules documented in the written convention, which are marked as enforced.Configurationni-python-styleguideaims to keep the configuration to a bare minimum (none wherever possible).
However there are some situations you might need to configure the tool.Fixni-python-styleguidehas a subcommandfixwhich will runblackandisort.Additionally, you can runfixwith the--aggressiveoption and it will add acknowledgements (# noqa) for the remaining linting errors
it cannot fix, in addition to running black and isort.When usingsetup.pyIf you're usingsetup.py, you'll need to set your app's import names for import sorting.# pyproject.toml[tool.ni-python-styleguide]application-import-names="<app_name>"Formattingni-python-styleguidein the future will have aformatcommand which we intend to fix as many lint issues as possible.Until then you'll want to set the following to getblackformatting as the styleguide expects.# pyproject.toml[tool.black]line-length=100Editor Integration(This section to come!)
Package: niq
niqAvailable utilities:Cache function calls results on diskInstallationpipinstallniqUsagefromniqimportcache@cachedeff():passBy default the cache decorator saves the function result in~/.niqand loads it if environment variableNIQ_CACHEis set to 1.You can customize cache location with thecache_dirparameter@cache(cache_dir='/path/to/custom/cache_dir')deff():passTestsTests are available undertests/, usepytestto run them
Package: nir
NIR - Neuromorphic Intermediate RepresentationNIR is a set of computational primitives, shared across different neuromorphic frameworks and technology stacks.NIR is currently supported by 7 simulators and 4 hardware platforms, allowing users to seamlessly move between any of these platforms.
The goal of NIR is to decouple the evolution of neuromorphic hardware and software, ultimately increasing the interoperability between platforms and improving accessibility to neuromorphic technologies.InstallationNIR is installable viapippipinstallnirCheck yourlocal frameworkfor NIR support.UsageRead more in ourdocumentation about NIR usageTo end-users, NIR is just a declarative format that sits between formats and will hopefully be as invisible as possible.
However, it is possible to export Python objects or NIR files.importnir# Write to filenir.write("my_graph.nir",nir_graph)# Read fileimported_graph=nir.read("my_graph.nir")About NIRRead more in ourdocumentation about NIR primitivesOn top of popular primitives such as convolutional or fully connected/linear computations, we define additional compuational primitives that are specific to neuromorphic computing and hardware implementations thereof.
Computational units that are not specifically neuromorphic take inspiration from the Pytorch ecosystem in terms of naming and parameters (such as Conv2d that uses groups/strides).Frameworks that currently support NIRFrameworkWrite to NIRRead from NIRExamplesLava-DL✓⬚Lava/Loihi examplesNengo✓✓Nengo examplesNorse✓✓Norse examplesRockpool(SynSense Xylo chip)✓✓Rockpool/Xylo examplesSinabs(SynSense Speck chip)✓✓Sinabs/Speck examplessnnTorch✓✓snnTorch examplesSpiNNaker2⬚✓SpiNNaker2 examplesSpyx⬚✓Spyx examplesAcknowledgementsThis work was originally conceived at theTelluride Neuromorphic Workshop 2023by the authors below (in alphabetical order):Steven AbreuFelix BauerJason EshraghianMatthias JobstGregor LenzJens Egholm PedersenSadique SheikPeng ZhouIf you use NIR in your work, please cite thefollowing arXiv preprint@inproceedings{NIR2023,
  title={Neuromorphic Intermediate Representation: A Unified Instruction Set for Interoperable Brain-Inspired Computing},
  author={Jens E. Pedersen and Steven Abreu and Matthias Jobst and Gregor Lenz and Vittorio Fra and Felix C. Bauer and Dylan R. Muir and Peng Zhou and Bernhard Vogginger and Kade Heckel and Gianvito Urgese and Sadasivan Shankar and Terrence C. Stewart and Jason K. Eshraghian and Sadique Sheik},
  year={2023},
  doi={https://doi.org/10.48550/arXiv.2311.14641}
  archivePrefix={arXiv},
  primaryClass={cs.NE}
}
Package: niraapad
# Niraapad
Prototype for the CPS security project## DependenciesPython 3.7.3Python package grpcio 1.32.0Python package grpcio-tools 1.32.0Python package protobuf 3.15.6Python package tensorflow 2.4.1The package may work with earlier versions of these depenencies, but this has not been tested.## StyleguideWe try to follw the [Google Python Style Guide](https://google.github.io/styleguide/pyguide.html)In order to use a tool like [YAPF](https://github.com/google/yapf) (Yet Another Python Formatter) for auto-formatting:Runyapf –style google -i -r -vv files .in the niraapad folder, orRunyapf –style google -i -vv files <filepath>to format a specific file## Build StepsGenerate the gRPC stubs using one of the following methods:Runscripts/compile_proto_files.shscript in bashRun taskbuilddefined in.vscode/tasks.jsonin Visual Studio Code## Testing StepsTest on a single machine using one of the following methods:Run.niraapadtesttest_middlebox.pyRun tasktestdefined in.vscode/tasks.jsonin Visual Studio CodeTest on two machines as follows:On the server machine, run.niraapadmiddleboxstart_server.py -P 1337 -K .niraapadkeysispy_cs_ubc_ca-SOn the client machine, run.niraapadtesttest_niraapad.py -D -H ispy.cs.ubc.ca -P 1337 -K .niraapadkeysispy_cs_ubc_ca-S(Use.niraapadmiddleboxstart_server.py –helpor.niraapadtesttest_niraapad.py –helpfor details)#### Running UR simulatorDetails on setting up UR simulator and connecting it with python script:https://github.com/ubc-systopia/cps-security-code/blob/main/docs/URsim_Setup.pdfTest on a single machine as follows:Turn on the VMware Player and run the UR simulator virtual machineRun the UR3 robot simulator and turn on the robot from the button on the bottom leftRun thetest_init_vmtest usingniraapad/test/test_middlebox.pyTest on two machines as follows:TODO## DistributionTo distribute theniraapadpackage on Python Package Index:Clean all old files related to distribution usingrm -rf build/ dist/ *egg*Update the version info in file__version__.pyGenerate the distribution package usingpython3 setup.py sdist bdist_wheelRuntwine check dist/*to check for errors and warningsIf you want to test the final package, upload it first to TestPyPI server usingtwine upload –repository testpypi dist/*The package can be installed from TestPyPI server usingpip install -i https://test.pypi.org/simple/ niraapad==1.1.0After the package is tested, upload it to the PyPI server usingtwine upload dist/*Currently, Arpan Gujarati is the sole owner and maintainer of theniraapadpackage on Python Package Index
Package: nirah
DescriptionArke is an interface designed messages from your long running processes
through the command line or in python through a standard interface. This
project is in the early stages of its development and will hopefully come
to provide a standard API for users to develop against.SettingsThe API keys can be stored in a file~/.config/hermes/settings.jsonwith
the following format:{
    "discord_key" : "your discord key",
    "twillio" : {
        "number": "your number",
	    "account_sid": "your account sid",
	    "auth_token": "your auth token"
    }
}Alternatively you may provide the relevant API keys as a token with a method
specific format.
Package: nirdust
NIRDust: Near Infrared Dust FinderNIRDust is a python package that uses K-band (2.2 micrometers) spectra to
measure the temperature of the dust heated by an Active Galactic Nuclei (AGN)
accretion disk.Motivation:K-band nuclear/circumnuclear spectral continuum of Type 2 AGNs is often composed of two
components: the stellar population emission and a hot 700 - 1600 K dust component.
If a Reference Spectrum is used to model the stellar emission, the dust component
can be fitted by a blackbody function in order to obtain its temperature.FeaturesThe package provides several functionalities to pre-process spectra and fit the
hot dust component of a AGN K-band spectrum with black body functions.NIRDust needs a minimum of two spectra to run: a target one, where the dust
temperature will be determined, and a reference spectrum, where the emission
is considered to be purely stellar. The reference spectrum spectrum will be used by
NIRDust to model the stellar emission from the target spectrum.Footnote: the hot dust component may or may not be present in your type 2
nuclei, do not get disappointed if NIRDust finds nothing.RequerimentsYou will need Python 3.8 or higher to run NIRDust.InstallationYou can install the least stable version of NIRDust from pip:$pipinstallnirdustOr, for the develovepment instalation clone this repository and then inside the local directory execute$pipinstall-e.Authors: Gaia Gaspar, José Alacoria, Juan B. Cabral & Martin Chalela
Package: nireports
NiReports: theNiPreps’ reporting and visualization toolsNiReportscontains the two main components of thevisual reporting systemofNiPreps:Reportlets: visualizations for assessing the quality of a particular processing step within the neuroimaging pipeline.
Typically, reportlets show brain mosaics perhaps with contours and/or segmentations.
They can bedynamicand flicker between two differentstatesto help assess the accuracy of image registrations.
However, the reportlets are not limited to brain mosaics, and can contain correlation plots, BOLD fMRIcarpetplots, etc.Assembler: end-userNiPrepswrite out reportlets to a predetermined folder, which is then queried by the assembler usingPyBIDS.
The assembler follows areport specificationin YAML format, which states the query to find specific reportlets and their corresponding metadata and text annotations.
As a result, one HTML file with a concatenation of reportlets is produced.
Package: nirfsg
nirfsgPython control of NI RF Signal Generators using NI-RFSGInstallation> pip install nirfsgOr, after cloning repo:> pip install .DocumentationCurrently supported models:PXIe-5654> from nirfsg import PXIe_5654
> sig_gen = PXIe_5654(<resource>)
> sig_gen.rf_frequency = 2e6 # Hz
> sig_gen.rf_power = 0 # dBm
> sig_gen.initiate()
...
> sig_gen.close()As a context manager:> with PXIe_5654(<resource>) as sig_gen:
    sig_gen.rf_frequency = 20e9 # Hz
    sig_gen.rf_power = 13 # dBm
    sig_gen.initiate()
    # do some measurementsContext manager will close the session at exit, which will stop generation.To discover available methods and attributes use tab-completion, dir() and help():In [1]: from nirfsg import PXIe_5654

In [2]: sg = PXIe_5654("PXI1Slot7")

In [3]: dir(sg)
Out[3]:
['abort',
 'amplitude_settling',
 'automatic_thermal_correction',
 'check_status',
 'clock',
 'close',
 'configurationlist',
 'configure_rf',
 'device_temperature',
 'events',
 'external_cal',
 'fast_tuning',
 'frequency_settling',
 'frequency_settling_units',
 'generation_mode',
 'initiate',
 'instrument_model',
 'modulation',
 'module_revision',
 'output_enabled',
 'pulse_modulation_enabled',
 'pulse_modulation_mode',
 'rf_frequency',
 'rf_power',
 'serial_number',
 'triggers',
 'wait_until_settled']

In [4]: dir(sg.clock)
Out[4]: ['reference_clock_output_terminal', 'reference_clock_source']

In [5]: sg.clock.reference_clock_source
Out[5]: <reference_clock_source.onboard clock: 'OnboardClock'>

In [6]: help(type(sg.clock.reference_clock_source))
Help on class reference_clock_source in module nirfsg.attributemonger:

class reference_clock_source(enum.Enum)
 |  reference_clock_source(value, names=None, *, module=None, qualname=None, type=None, start=1)
 |
 |  An enumeration.
 |
 |  Method resolution order:
 |      reference_clock_source
 |      enum.Enum
 |      builtins.object
 |
 |  Data and other attributes defined here:
 |
 |  none = <reference_clock_source.none: 'None'>
 |
 |  onboard clock = <reference_clock_source.onboard clock: 'OnboardClock'>
 |
 |  pxi clk = <reference_clock_source.pxi clk: 'PXI_CLK'>
 |
 |  pxi clk master = <reference_clock_source.pxi clk master: 'PXI_ClkMaste...
 |
 |  ref in = <reference_clock_source.ref in: 'RefIn'>
 |
 |  ref in 2 = <reference_clock_source.ref in 2: 'RefIn2'>
Package: nirsimple
NIRSimplefNIRS signal processing simplifiedNIRSimpleis a Python 3 package for fNIRS with a focus on signal processing. It gives control on preprocessing and processing, enabling to adjust parameters and use different methods from the scientific literature.This package handles data as numpy arrays. It can be used withMNEpipelines by creating MNE-specific objects (Raw, Epochs, ...) from numpy arrays.Featuresconversion fromlight intensitytooptical density changesconversion fromoptical density changestohemoglobin concentration changeswith themodified Beer-Lambert law(options for different extinction coefficient tables)signal correction withcorrelation based signal improvement(CBSI)DocumentationThe documentation of the library can be foundhere.InstallIn a terminal or a command prompt, run:pip install nirsimpleKeep the package up to dateIn a terminal or a command prompt, run:pip install --upgrade nirsimpleExampleAn example of usingNIRSimplewith MNE can be foundhere.AcknowledgementsUntil there is an article specifically onNIRSimple, please citethis article.
Package: nirtorch
NIRTorchPyTorch helpers for theNeuromorphic Intermediate Representation (NIR).
This is a no frills python package to enable torch based libraries to translate to NIR.InstallationpipinstallnirtorchUsageNIRTorch is typically only interfaced by library/hardwarae developers.
NIRTorch provides theextract_nir_graphfunction that takes as input atorch.nn.Moduleand a means to map Torch modules into NIR nodes.
An NIR node is an element in the NIR compute graph, corresponding to neuromorphic ODEs.Here is an example from theNorselibrary:def_extract_norse_module(module:torch.nn.Module)->Optional[nir.NIRNode]:ifisinstance(module,LIFBoxCell):returnnir.LIF(tau=module.p.tau_mem_inv,v_th=module.p.v_th,v_leak=module.p.v_leak,r=torch.ones_like(module.p.v_leak),)elifisinstance(module,torch.nn.Linear):returnnir.Linear(module.weight,module.bias)elif...returnNonedefto_nir(module:torch.nn.Module,sample_data:torch.Tensor,model_name:str="norse")->nir.NIRNode:returnextract_nir_graph(module,_extract_norse_module,sample_data,model_name=model_name)AcknowledgementsIf you use NIR torch in your work, please cite thefollowing Zenodo reference@software{nir2023,
  author       = {Abreu, Steven and
                  Bauer, Felix and
                  Eshraghian, Jason and
                  Jobst, Matthias and
                  Lenz, Gregor and
                  Pedersen, Jens Egholm and
                  Sheik, Sadique},
  title        = {Neuromorphic Intermediate Representation},
  month        = jul,
  year         = 2023,
  publisher    = {Zenodo},
  version      = {0.0.1},
  doi          = {10.5281/zenodo.8105042},
  url          = {https://doi.org/10.5281/zenodo.8105042}
}For developersIf you want to make sure that your code is linted correctly on your local machine, usepre-committo automatically perform checks before every git commit. To use it, first install the package in your environmentpip install pre-commitand then install the pre-commit hooks that are listed in the root of this repositorypre-commit installNext time you commit some changes, all the checks will be run!
Package: nirum-http
Nirum HTTP transport for PythonThis package provides an HTTP transport fornirum-python.fromyoutserviceimportYourService_Clientfromnirum_httpimportHttpTransporttransport=HttpTransport('https://service-host/')client=YourService_Client(transport)SinceHttpTransportutilizesrequestslibrary under the hood, it can take
asession objectas well:fromrequestsimportSessionsession=Session()session.auth=('user','password')transport=HttpTransport('https://service-host/',session=session)ChangelogVersion 0.1.1Released on August 3, 2017.Fixed a bug that message ofUnexpectedNirumResponseErrorwas not astrbutunicodein Python 2.Version 0.1.0Released on July 10, 2017.
Package: nisaba
Nisaba 0.3.15A tool for multi-modal annotationMost Recent UpdateFixed errors associated with duplicate or missing taxonomy entriesSome refactoring of codeFull Change LogandDevelopment RoadmapEasy (PIP) Installation:Nisabais now available throughPyPi.
To install using pip, simply run the following command from your terminal:pip install nisabaAfter installation, runNisabausing the command:nisabaContributingIf you wish to contribute to the development ofNisaba, clone and run from the source code using the following commands from your terminal:git clone https://github.com/mhbeals/nisaba
cd nisaba
virtualenv .
source bin/activate
pip install -r requirements.txtTo run, usecd nisaba
python __main__.pyor simply:python -m nisabaDevelopment HistoryNisabawas conceived byM. H. Beals(Loughborough University) andOlivia Mitchell(Loughborough University) as part of her PhD project (2017-present).Initial development of the software (v.0.1.0) was undertaken byM. H. Bealsin 2018-2019.The project is now being developed byM. H. BealsandAlbert MeroÃ±o PeÃ±uela(Vrije Universiteit Amsterdam). If you would like to contribute, please contactM. H. Beals(or submit a pull request!)
Package: nisanyan-cli
CLI tool for Turkish etymological dictionary,nisanyansozluk.com.Installpip install nisanyan-cliUsege$ nis yakamozEtymology Tree (--tree,-t):$ nis çikolata --tree
çikolata (Günümüz Türkçesi)
└── cioccolata (İtalyanca): kakao yağı ve şekerle imal edilen yiyecek maddesi.
    └── chocolate (İspanyolca): ~.
        └── xocolatl (Aztekçe): kakaodan yapılan içecek.
            ├── xocolli (Aztekçe): acı.
            └── atl (Aztekçe): su.Random Word (--random,-r):$ nis -r -t
menekşe (Günümüz Türkçesi)
└── banafşe ‹بنفشه› (Farsça): aynı anlam.
    └── vanavşag (Orta Farsça 1300—1500): aynı anlam.
        └── *vana-vaxşa- (Avestaca MÖ.2000): orman otu.
            └── vaxşaiti, vaxş- (Avestaca MÖ.2000): yetişmek, bitmek (bitki).Adlar (-ad):$ nis gökçe -adAlso you can use--random,-rargument with-adargument:nis -ad -rArgumentspositional arguments:
    <word>

options:
    -h, --help     show this help message and exit
    -t, --tree     show result as etymology tree
    -r, --random   selects a random word and brings the result
    -p, --plain    plain text output
    -ad            show result from nisanyanadlar
    -v, --version  show program's version number and exitTODOKöken metninin sitedeki gibi görünmesi için Api'dan dönen sonucun işlenmesi.Ek açıklama metnindeki kısaltmaların normal hallerine çevrilmesi.Dependenciesrich