Saravanan666/pypi-org huggingface dataset:
Package: nmrpoise
Parameter Optimisation by Iterative Spectral EvaluationJonathan Yong and Mohammadali Foroozandeh, University of OxfordAnal. Chem.2021,93(31), 10735–10739.DOI: 10.1021/acs.analchem.1c01767OverviewPOISE is a Python package for the numerical optimisation of NMR parameters.
It works by iteratively acquiring NMR spectra with different parameters and using a cost function to determine the optimal point.The software comprises two parts:the user-facingfrontend, which runs in Bruker's TopSpin software. It can be executed from the TopSpin command line, or called from an AU or Python script (the documentation contains more instructions on this).thebackend, which is hidden from the user; it runs on a system installation of Python 3.6+.InstallationTo install POISE, you will need:TopSpin. The minimum tested version is 3.6; however, this should work on any version of TopSpin that has Python 2.7 internally bundled (older versions of Python 2 are not currently supported). To check which version of Python comes with TopSpin, followthese instructions.Note that other instrument manufacturers are not currently supported.Python 3.6 or later.This refers to a system installation, which is entirely separate from that in TopSpin. Please download and install that (many instructions are available online).POISE can then be installed usingpip(which uses the system installation of Python):python -m pip install nmrpoise   # or 'python3'If any errors occur, please seethe documentation, or contact us.To upgrade or reinstall POISE use:python -m pip install --upgrade nmrpoise --no-cache-dirNote that the--no-cache-dirflag is necessary if you are reinstalling (its purpose is explained in thedocumentation).DocumentationThe documentation is hosted athttps://foroozandehgroup.github.io/nmrpoise; it contains complete instructions on how to set POISE up and use it.There is also a video guide available athttps://www.youtube.com/watch?v=QTCeSCRZs4I.Contact usAny feedback, questions, or bugs? Pleasecreate a GitHub issueor email us: we can be reached atfirstname.lastname@chem.ox.ac.uk.
Package: nmrpy
NMRPy is a Python 3 module for the processing and analysis of NMR spectra. The
functionality of NMRPy is structured to make the analysis of arrayed NMR
spectra more intuitive and is specifically targeted to the quantification of
reaction time-courses collected with NMR.NMRPy features a set of easy-to-use tools for:
- easy loading of spectra from a variety of vendors,
- bulk Fourier transform and phase correction of arrayed spectra,
- peak selection (programmatically or using graphical widgets),
- integration of peaks by deconvolution.NMRPy is developed by Johann Eicher and Johann Rohwer from the Laboratory for
Molecular Systems Biology, Dept. of Biochemistry, Stellenbosch University,
South Africa.
Package: nmrquant
NMRQuant is a software for the quantification of metabolites from 1D Proton NMR experiments.
It takes as input integrated areas from spectra and proton counts from a database from excel and
csv files. It can be used with either internal or external calibration, using a standard. It outputs
an excel file containing the calculated concentrations, and svg files containing plots that help
with the visualisation and interpretation of the data.It is one of the routine tools used on theMetaToul platform.The code is open-source, and available on Github under a GPLv3 license.The documentation relative to NMRQuant’s usage can be found onReadTheDocs.It can be used from a command line interface or through an interactive jupyter notebook GUI. The notebook can be
downloaded from theGitHub page.Key FeaturesCalculation of metabolite concentrations from 1D H+ NMR integrated dataCreation of figures (lineplots and barplots) that help with interpretation
Package: nmrsim
Click the “Launch Binder” link above
to see hownmrsimcan be used in Jupyter notebooks.Documentation on Read the Docsnmrsimnmrsimis a Python library for the simulation of solution-state nuclear magnetic resonance (NMR) spectra.The project is inspired by the programWINDNMRby Hans
Reich. The goal for Version 1.0 ofnmrsimis to provide Python tools for the same types of simulations that
WINDNMR did–first- and second-order simulation of spin-1/2 spin systems, plus simulation of some dynamic NMR (DNMR)
lineshapes. A longer-term goal is to expand the toolset (e.g. to allow higher-spin nuclei, or new DNMR models).FeaturesClass-based abstractions for NMR features (nmrsim.Multiplet;nmrsim.SpinSystem;nmrsim.Spectrum).Convenience functions for quickly plotting simulation results (nmrsim.plt).A lower-level API for more “hands-on” calculation of NMR spectra (e.g. functions for creating and solving spin
Hamiltonians innmrsim.qm).ExamplesSee the documentation, or the notebooks in the Jupyter folder, for examples of typical use cases.Installationpip install nmrsimSee theDeveloper Pagefor details on installing a developer version into a virtual environment.ContributeSee theContributing to nmrsimpage for details
on how to contribute to the project.
You don’t have to have any particular expertise!
If you’ve used (or tried to use) the library and have suggestions,
you can make a valuable contribution.
Package: nmr-sims
nmr_simsNMR simulations in Python.Some rather simple simulations of basic NMR pulse sequences.Everything uses the Zeeman basis in Hilbert space, so nothing too fancy is possible.Currently have pulse-acquire, 2DJ, and HSQC code available.Install with$pip install nmr-simsTo get started, take a look at (and run)$python -m nmr_sims pa,$python -m nmr_sims jresor$python -m nmr_sims hsqc.DOCUMENTATION
Package: nmrstarlib
Thenmrstarlibpackage is a Python library that facilitates reading and writing
NMR-STAR formatted files used by the Biological Magnetic Resonance Data Bank (BMRB)
for archival of Nuclear Magnetic Resonance (NMR) data and CIF formatted files used
by Protein Data Bank (PDB).Thenmrstarlibpackage provides facilities to convert NMR-STAR and CIF formatted
files into their equivalent JSONized representation and vice versa. JSON stands
for JavaScript Object Notation, an open-standard format that uses human-readable
text to transmit data objects consisting of attribute-value pairs.Thenmrstarlibpackage also provides facilities to create simulated peak lists for
different types of standard solution and solid-state NMR experiments from chemical
shifts and assignment information deposited in NMR-STAR files.In addition, thenmrstarlibpackage provides methods to visualize chemical shift data.Thenmrstarlibpackage can be used in several ways:As a library for accessing and manipulating data stored in NMR-STAR and CIF formatted files.As a command-line tool to convert between NMR-STAR/CIF format and its equivalent JSONized
NMR-STAR/CIF format, to create a large number of simulated peak lists,
and also to visualize chemical shift data from NMR-STAR formatted files.CitationWhen usingnmrstarlibin published work, please cite the following paper:Smelter, Andrey, Morgan Astra, and Hunter NB Moseley. “A fast and efficient python
library for interfacing with the Biological Magnetic Resonance Data Bank.”BMC Bioinformatics18.1 (2017): 175. doi:10.1186/s12859-017-1580-5.Linksnmrstarlib @GitHubnmrstarlib @PyPIDocumentation @ReadTheDocsInstallationThenmrstarlibpackage runs under Python 2.7 and Python 3.4+. Usepipto install.
Starting with Python 3.4,pipis included by default.Install on Linux, Mac OS Xpython3-mpipinstallnmrstarlibInstall on Windowspy-3-mpipinstallnmrstarlibQuickstartImportnmrstarliblibrary and create generator function that will yieldStarFileinstance(s):>>>importnmrstarlib>>>>>># "path": path_to_file / path_to_dir / path_to_archive / bmrb_id / pdb_id / file_url>>>forfileinnmrstarlib.read_files("path"):...print(file.id)# print BMRB/PDB id of a file...print(file.source)# print source of a file...print(file.keys())# print top-level keys>>>NoteRead theUser GuideandThe nmrstarlib TutorialonReadTheDocsto learn more and to see code examples on using thenmrstarlibas a
library and as a command-line tool.LicenseThis package is distributed under theMITlicense.
Package: nmslib
Non-Metric Space Library (NMSLIB) is an efficient cross-platform
similarity search library and a toolkit for evaluation of similarity search methods.
The goal of the project is to create an effective and comprehensive toolkit for searching
in generic and non-metric spaces. Even though the library contains a variety of metric-space
access methods, our main focus is on generic and approximate search methods, in particular,
on methods for non-metric spaces. NMSLIB is possibly the first library with a principled
support for non-metric space searching.
Package: nmslib-metabrainz
Non-Metric Space Library (NMSLIB) is an efficient cross-platformsimilarity search library and a toolkit for evaluation of similarity search methods.
The goal of the project is to create an effective and comprehensive toolkit for searching
in generic and non-metric spaces. Even though the library contains a variety of metric-space
access methods, our main focus is on generic and approximate search methods, in particular,
on methods for non-metric spaces. NMSLIB is possibly the first library with a principled
support for non-metric space searching.
Package: nmslib-viz
NMSLIB-viz📊 NMSLIB visualization toolInstallationInstall client via pip. Ideally,nmslib-vizis well supported for Python >= 3.7.pip3installnmslib-viz--no-binarynmslibThe--no-binaryoption is important for a better CPU performance.UsageJust run it like this:nmslib-vizINDEX_FILE_PATH[--number_pointsNUMBER_POINTS]Arguments:INDEX_FILE_PATH: String pointing to the NMSLIB file path. There has to be the additional .dat file for the index, the one that is created when uses thesave_data=Trueoption in the saveIndex() function. For example:index.nmslibandindex.nmslib.datneed to exist but onlyindex.nmslibhas to be provided as this parameter.NUMBER_POINTS: (optional) Number of points as a maximum to plot from the NMSLIB index data, where has to be 1 at least. Default value: 1000.ResultNote: this example is a representation of theSearchLyindex.DevelopmentRecommendationsUsage ofvirtualenvis recommended for package library / runtime isolation.InstallationSetup virtual environmentInstall dependenciespip3install-rrequirements.lockInstall locallypip3install.--no-binarynmslibContributingSuggestions, improvements, and enhancements are always welcome! If you have any issues, please do raise one in the Issues section. If you have an improvement, do file an issue to discuss the suggestion before creating a PR.All ideas – no matter how outrageous – welcome!AuthorsAlbert SuàrezLicenseApache-2.0 © nmslib-viz
Package: nmstate
We are Nmstate!A declarative network manager API for hosts.Copr build status, all repos are built for Fedora Linux and RHEL/CentOS Stream/EPEL 8+:Latest release:Git base:What is it?Nmstate is a library with an accompanying command line tool that manages
host networking settings in a declarative manner.
The networking state is described by a pre-defined schema.
Reporting of current state and changes to it (desired state) both conform to
the schema.Nmstate is aimed to satisfy enterprise needs to manage host networking through
a northbound declarative API and multi provider support on the southbound.
NetworkManager acts as the main (and currently the only) provider supported.State example:Desired/Current state example (YAML):interfaces:-name:eth1type:ethernetstate:upipv4:enabled:trueaddress:-ip:192.0.2.10prefix-length:24dhcp:falseipv6:enabled:trueaddress:-ip:2001:db8:1::aprefix-length:64autoconf:falsedhcp:falsedns-resolver:config:search:-example.com-example.orgserver:-2001:4860:4860::8888-8.8.8.8routes:config:-destination:0.0.0.0/0next-hop-address:192.0.2.1next-hop-interface:eth1-destination:::/0next-hop-address:2001:db8:1::1next-hop-interface:eth1Basic OperationsShow eth0 current state (python/shell):importlibnmstatestate=libnmstate.show()eth0_state=next(ifstateforifstateinstate['interfaces']ififstate['name']=='eth0')# Here is the MAC addresseth0_mac=eth0_state['mac-address']nmstatectlshoweth0Change to desired state (python/shell):importlibnmstate# Specify a Linux bridge (created if it does not exist).state={'interfaces':[{'name':'br0','type':'linux-bridge','state':'up'}]}libnmstate.apply(state)# use yaml or json formatsnmstatectlsetdesired-state.yml
nmstatectlsetdesired-state.jsonEdit the current state(python/shell):importlibnmstatestate=libnmstate.show()eth0_state=next(ifstateforifstateinstate['interfaces']ififstate['name']=='eth0')# take eth0 downeth0_state['state']='down'libnmstate.apply(state)# open current state in a text editor, change and save to applynmstatectlediteth3ContactNmstateuses thenmstate-devel@lists.fedorahosted.orgfor
discussions. To subscribe you can send an email with 'subscribe' in the subject
tonmstate-devel-join@lists.fedorahosted.orgor visit themailing list page.Sprint tracking happens in
(Github projects).There is also#nmstateonLibera IRC.ContributingYay! We are happy to accept new contributors to the Nmstate project. Please follow
theseinstructionsto contribute.InstallationFor Fedora 29+,sudo dnf install nmstate.For others distribution, please see theinstall guide.Documentationlibnmstate APICode examplesState examplesnmstatectl user guidenmstatectl man page:man nmstatectlLimitationsMaximum supported number of interfaces in a single desire state is 1000.ChangelogPlease refer toCHANGELOG
Package: nms-ts
NMS Lore TranslatorWith the Echoes update, No Man's Sky introduced some dialogue written in binary. I created this tool so that I could easily grab the screen, extract the binary text, and then convert it to UTF-8 characters. It will then append each new bit of lore to a file in your home folder.CaveatsThis was only tested on Ubuntu 23.04 with a screen resolution of 1920x1080 and the game running in full screen. It should, theoretically, work on any OS with the Tesseract OCR library installed, but it has not at all been tested and I take no responsibilites for this.InstallationYou can either clone this repository and then runpoetry build && pip3 install --user dist/nms_ts-<version>-py3-none-any.whlor you can install from PyPi with justpip3 install --user nms-tsUsageThe script runs and copies everything it sees on the screen within the resolution as soon as you call it. This could cause issues if your terminal pops up over the game as it will try to read binary from that as well and then fail because it's not proper binary. I would suggest, instead, binding to a hotkey:nms --xend=<your X resolution> --yend=<your Y resolution>Then, when you hit your hotkey, it will run the script without launching a terminal, therefore introducing no confusion for the script. Doing it like that will make it capture your entire display and attempt to extract from there. However, you can also specify just a small portion of your screen (to get a more exact area to translate and minimize possible errors) by specifying more exactxstart,ystart,xendandyendvalues.Changelogv1.1.3Preserve spacesv1.1.2Actually fixed the damn thingv1.1.1Fixed capture and translatev1.1.0Added option to set boundary boxMade it so that values actually get passed to grab functionNow filters out characters that are not proper binary digitsv1.0.0Initial release
Package: nmt
# Neural Machine Translation (NMT)## DescriptionThis is the Neural Machine Translation package for NLPIA 2nd Edition. Currently support Spanish-English Seq2Seq model using 1-layer GRU with Bag-of-Word accuracy## InstallationIf you just want to install nmt package from PyPI channel:`console $ pip installnmt==0.0.4`If you want to modify the source code to run experiments you’ll need to install dependencis in an environment and then install the package in–editablemode.### EnvironmentDependencies:NLTKeditdistanceCreate a conda environment where you can install all the dependencies like pytorch, pandas, nltk, spacy, and scikit-learn.
Jupyter is also installed so developers can experiment injupyter console(ipython) and Data Scientists can usejupyter notebook.`console $ conda update-y-nbase-cdefaults conda $ conda create-y-nnmt 'python=3.7.9' $ conda env update-nnmt-fenvironment.yml $ conda activate nmt || source activate nmt `## Usage### Train an NMT modelActivate conda env with thenmtpackage installednmt –config ${model_hyperparameter_json} –epochs ${num_epoch} –data_path ${training_file} –model_checkpoint_dir ${export_path} –metrics_dir ${metrics_path}### ParametersModel Hyperparameter Json: Name of the config file (under the experiment subdirectory)Epoch: Number of EpochTraining Text File: Directory of the training corpus (.txt)Model Checkpoint Path: Directory to save model checkpointMetric Directory: Directory to save learning curve and model metrics## Roadmap
- [ ] 0. [Add badge for unittests](https://docs.gitlab.com/ee/user/project/badges.html) to README.md
- [ ] 0. Push release to pypi:git tag -a 0.0.6 -m ‘toy_problem.py works!’ && python setup.py sdist bdist_wheel upload- [x] 1. Set up a simple decoder-encoder model using GRU cells, BLEU score as evaluation metrics
- [x] 2. Conduct hyperparameter search
- [x] 3. Add Attention Mechanism to Decoder-Encoder module
- [ ] 4. Incorporate transfer learning from BERT or other models## Directory structureCode Structure within source directory:
- experiments: submodule where hyperparameters are stored in json format and retrieved as config
- models: submodule where Decoder, Encoder, Seq2Seq models are stored
- utils: submodule where Word Dictionary and Data Preprocessing functions are found
- main_script.py: script to kick start model training
- training.py: script to walk through the whole training process## Credits/References:[Benjamin Etienne’s repo](https://github.com/b-etienne/Seq2seq-PyTorch/)[PyTorch’s documentation on Seq2Seq](https://pytorch.org/tutorials/intermediate/seq2seq_translation_tutorial.html)
Package: nmtf
permalink: /docs/index.htmlDocshttps://paulfogel.github.io/NMTF/NMTFNon-Negative Matrix and Tensor FactorizationsDevelopped in collaboration withAdvestis(Github)ArticlesPeer-reviewed articles(researchgate) A Tale of Two Matrix Factorizations(researchgate) Fast Local Algorithms for Large Scale Nonnegative Matrix and Tensor Factorizations(nature) Learning the parts of objects by non-negative matrix factorizationBlog articles(Medium) Using Non-negative matrix factorization to classify companies(offconvex)Tensor Methods in Machine Learning
Package: nmtvis
nmtvisnmtvisis a visualization toolkit for NMT(Neural Machine Translation) system.InstallationUse pip to installnmtvis:pip install nmtvisFeaturesVisualize attention weights in attention-based NMT modelsVisualize high-dimensional vectors(e.g. word embeddings)Visualize the beam search decoding processLinksSource Code:https://github.com/player-eric/NMT-VisualizerDocumentation:https://nmtvis.readthedocs.io/en/latest/LicenseThe project is licensed under the MIT license.SupportIf you are having issues, please let me know.
Contact me atdigimonyan@gmail.com
Package: nmurl
nmurlnmurl combines nmap output and DNS data to produce HTTP[S] URLs of interest.Examples / UsagePerform an Nmap scan on your desired target:> nmap 10.32.64.0/27 -oX scan.xml

Starting Nmap 6.47 ( http://nmap.org ) at 2016-08-31 02:26 EDT
Nmap scan report for 10.32.64.1
Host is up (0.071s latency).
PORT    STATE  SERVICE
80/tcp  closed http
443/tcp closed https

Nmap scan report for 10.32.64.2
Host is up (0.073s latency).
PORT    STATE    SERVICE
80/tcp  filtered http
443/tcp filtered https

Nmap scan report for www.example.com (10.32.64.4)
Host is up (0.075s latency).
PORT    STATE SERVICE
80/tcp  open  http
443/tcp open  httpsGet forward lookup data into some file(s) using dig, nmine or anything which
produces DNS data in BIND zone file format:> cat lookups 
host1.example.com.               600 IN A 10.32.64.1
host2.example.com.               600 IN A 10.32.64.2
www.example.com.                 600 IN CNAME host2.example.com
example.com.                     600 IN A 10.32.64.2
host4.example.com.               600 IN A 10.32.64.4Use nmurl to get a list of URLs based on a combination of both data sources:> nmurl scan.xml -n lookups
http://10.32.64.1
http://host1.example.com
https://10.32.64.1
https://host1.example.com
https://10.32.64.2
https://example.com
https://host2.example.com
https://www.example.com
http://10.32.64.4
http://host4.example.com
https://10.32.64.4
https://host4.example.comThe URLs above are sorted by IP address and port number.Options(loose arguments): Filename(s) of Nmap XML output files. Specify at least
once.  No duplicate URLs will be output.-n NAMEFILES: Filename of DNS lookup data in BIND zone file
format.  May be specified multiple times.-S FORCEHTTPSPORTS: If this port is open, assume it is HTTPS regardless of
nmap's stated service name-H FORCEHTTPPORTS: If this port is open, assume it is HTTP regardless of
nmap's stated service name-v: Display version number and exit.-d: Turn on debug logging output.Copyright and LicenseCopyright (C) 2016 Hurricane Labsnmurl was written by Steve Benson for Hurricane Labs.nmurl is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.nmurl is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
details.You should have received a copy of the GNU General Public License along with
this program; see the file LICENSE.  If not, seehttp://www.gnu.org/licenses/.
Package: nn
A neural network library built on top of TensorFlow for quickly building deep learning models.Usagenn.Tensoris the core data structure which is a wrapper fortf.Tensorand provides additional functionality. It can be created using thenn.tensor()function:importnna=nn.tensor([1,2,3])assertisinstance(a,nn.Tensor)asserta.shape==(3,)It supports method chaining:c=a.square().sum()assertc.numpy()==14and can be used withtf.Tensorobjects:importtensorflowastfb=tf.constant(2)c=(a-b).square().sum()assertc.numpy()==2It can also be used with high level APIs such astf.keras:model=nn.Sequential([nn.Dense(128,activation='relu'),nn.Dropout(0.2),nn.Dense(10)])y=model(x)assertisinstance(y,nn.Tensor)and to perform automatic differentiation and optimization:optimizer=nn.Adam()withnn.GradientTape()astape:outputs=model(inputs)loss=(targets-outputs).square().mean()grads=tape.gradient(loss,model.trainable_variables)optimizer.apply_gradients(zip(grads,model.trainable_variables))To use it with ops that expecttf.Tensorobjects as inputs, wrap the ops usingnn.op():mean=nn.op(tf.reduce_mean)c=mean(a)assertisinstance(c,nn.Tensor)maximum=nn.op(tf.maximum,binary=True)c=maximum(a,b)assertisinstance(c,nn.Tensor)or convert it to atf.Tensorobject using thetf()method ornn.tf()function:b=a.tf()assertisinstance(b,tf.Tensor)b=nn.tf(a)assertisinstance(b,tf.Tensor)See more exampleshere.InstallationRequirements:TensorFlow >= 2.0Python >= 3.6Install from PyPI (recommended):pipinstallnnAlternatively, install from source:gitclonehttps://github.com/marella/nn.gitcdnn
pipinstall-e.TensorFlowshould be installed separately.TestingTo run tests, install dependencies:pipinstall-e.[tests]and run:pytesttests