Saravanan666/pypi-org huggingface dataset:
Package: nescience
Machine Learningwith the Minimum Nescience Principlenescienceis a highly efficient open source library for machine learning based on Python and built on top ofscikit-learn. The library is based on theminimum nescience principle, a novel mathematical theory that measures how well we understand a problem given a representation and a description. In case of machine learning, representations are based on datasets, and descriptions are based on mathematical models.The minimum nescience principle allow us to automate the common tasks performed by data scientists, from feature selection, model selection, or hyperparameters optimization.nesciencecan dramatically increase the productivity of the data scientist, reducing the time to analyze and model a dataset. Withnesciencewe can have results in very short time, without decreasing the accuracy (in fact, we usually have a better accuracy).Nescienceis fast because:It does not requires cross-validationIt use a greedy search for hyperparametersIt is not based on ensembles of modelsThe LibraryThenesciencelibrary is composed of the following classes:Miscodingmeasures the quality of the dataset we are using to represent our problem.Inaccuracymeasures the error made by the model we have trained.Surfeitmeasures how (unnecessarily) complex is the model we have identified.All these metrics are combined into a single quantity, calledNescience, as a measure of how well we understand our problem given a dataset and a model.Nescienceallow us to evaluate and compare models from different model families.Thenesciencelibrary also contains the following utilities:Anomaliesfor the identification and classification of anomalies.Causalfor cause-effect analysis.Besides to these classes, thenesciencelibrary provide the following automated machine-learning tools:AutoRegressionfor automated regression problems.AutoClassificationfor automated classification problems.TimeSeriesfor time series based analysis and forecasting.User GuideThis user guide contains the following sections:Feature SelectionModel InaccuacyModel ComplexityHyperparameters SelectionAuto ClassificationAuto RegressionTime Series
Package: nesdict
# NesDict[![Build Status](https://travis-ci.org/Kargathia/nesdict.svg?branch=master)](https://travis-ci.org/Kargathia/nesdict)Intended to add easy-to-use lookup syntax to Python's builtin `dict()`, removing the need to chain `[]` operators or `.get()` calls.Example:```pythonfrom nesdict import NesDictxdata = NesDict({'path': {'to': {'nested': {'value': 'stuff','thing': 'more stuff','number': 42},'something': 'else'}}})xdata['/path/to/nested/value'] == 'stuff'xdata.search('/path/to/nested/*') == [('/path/to/nested/value', 'stuff'),('/path/to/nested/thing', 'more stuff'),('/path/to/nested/number', 42)]xdata.values() == ['stuff', 'more stuff', 42, 'else']```It also supports setting new values using the same syntax:```pythonxdata['/path/less/traveled/by'] = 'all the difference'xdata['/path'] == {'to': {'nested': {'value': 'stuff','thing': 'more stuff','number': 42},'something': 'else'},'less': {'traveled': {'by': 'all the difference'}}}```
Package: neseg
Named Entity Segmentation简介本项目是字符串令牌流分割库；
neseg -n 中国北京市联想科技有限公司 -d dict功能字符串令牌解析；支持令牌流；解析器可以是自定义字典机械分割，每个token一个独立字典；解析器也可以是正则表达式；分割分正向和反向，都是从头开始；生成对应令牌名称和解析出来的字符创元组，最后剩下的归为一组；应用场景各种名称的解析，如中文机构名、药品名称、地址的分割标注；TODO设计参考re.scanner；可以用生成器yield来做技术实现；程序返回元组列表；附录 - 源码文件说明neseg
    /lib
        FMM.py  正向切词
        RMM.py  反向切词
    seg.py      
    main.py   主程序：无界面,参数命令行
changelog.md    软件更新日志
readme.md       软件使用、安装指南
Package: neshan
Python Client for Neshan ServicesDescriptionThis library is a duplication ofhttps://github.com/googlemaps/google-maps-services-pythonwhich is changed to work with Neshan APIs. Please open an issue if you have any questions.The Python Client for Neshan Services is a Python Client library for the following Neshan
APIs:Static MapsDirections APIDistance Matrix APIReverse Geocoding APIMap Matching APISearch APIRequirementsPython 3.5 or later.A Neshan API key.Installation$ pip install -U neshanNote that you will need requests 2.4.0 or higher if you want to specify connect/read timeouts.UsageThis example uses the Geocoding API and the Directions API with an API key:importneshanfromdatetimeimportdatetimenmaps=neshan.Client(key='Add Your Key here')# Look up an address with reverse geocodingreverse_geocode_result=nmaps.reverse_geocode((40.714224,-73.961452))# Request directions via public transitnow=datetime.now()directions_result=nmaps.direction((36.268706,59.610011),(36.287607,59.599527))FeaturesRetry on FailureAutomatically retry when intermittent failures occur. That is, when any of the retriable 5xx errors
are returned from the API.Building the Project# Installing nox
$ pip install nox

# Running tests
$ nox

# Generating documentation
$ nox -e docs

# Copy docs to gh-pages
$ nox -e docs && mv docs/_build/html generated_docs && git clean -Xdi && git checkout gh-pagesDocumentation & resourcesAPI docsGet Started with Neshan PlatformDirections APIDistance Matrix APIReverse Geocoding APIMap Matching APISearch APISupportReport an issueContributeChangelogAll notable changes to this project will be documented in this file.[v1.1.1]FixedReadme.md and pypi package description[v1.1.0]AddedStatic maps api[v1.0.0]AddedInitial version
Package: nesiac
OverviewNesiac is a terminal tool for visualising memory usage in embedded programs.As an example when run on the STM32 "HID_Standalone" project for STM32H747I-DISCO board:InstallationNesiac may be installed with pip via:python -m pip install nesiacThenesiacexecutable will then be made available in your python executables directory, which should be on your path.UsageNesiac requires two files to do its analysis:An ELF file for section and symbol infoA map file (in GCC style) for memory region infoIf Nesiac is given a single path as argument, that path should be a directory containing exactly one.elfand one.mapfile. In that case, Nesiac will use those files for analysis.Alternatively those paths may be overriden with the-e,--elf-fileand-m,--map-filearguments.Exporting a map file from GCC may be enabled with the-Wl,-Map=<FILE>flag.If you are using a linker that cannot generate GCC style map files, then you can provide a dummy map file with the region info in the correct format:Memory Configuration

Name             Origin             Length             Attributes
FLASH            0x0000000008000000 0x0000000000100000 xr
RAM              0x0000000024000000 0x0000000000020000 xrw
ITCMRAM          0x0000000000000000 0x0000000000010000 xrw
*default*        0x0000000000000000 0xffffffffffffffffLanguagesNesiac will demangle C++ and Rust symbols when it finds them.
Package: neslab-find
FIND modelThis directory provides a Python implementation of the FIND model and protocol.The provided code allows to calculate the probability for each node in a clique to become active in any slot, the probability for any individual link to be discovered in any slot as well as the network discovery latency.InstallationDepending on your setup, install the python package together with the requirements for the examples usingpipenv install neslab.find[examples]orpip install neslab.find[examples]UsageInstantiate the model with a uniform distribution with scale 10 and three nodes with charging times of 100, 125 and 200 that become active for the first time without an offset:importmatplotlib.pyplotaspltfromneslab.findimportModelm=Model(10,"Uniform",[100,125,200],offset=0)Compute for every node the probability of being active in a slot and plot the results:act=m.activity()plt.plot(act[:2000])plt.show()Compute the cumulative distribution function (cdf) of the slot in which each of the three links between the three nodes is discovered and plot the results:cdfs=m.cdf()plt.plot(cdfs)plt.show()Compute the fraction of discovered links and plot the result:dff=m.disco_frac()plt.plot(dff)plt.show()Compute the discovery latency:lat=m.disco_latency())print(f"Discovery latency:{lat}slots")ExamplesWe provide more involved example scripts in theexamplesdirectory:To compare the probability of activity and the cdf of the corresponding discovery latency of two nodes with a charging time of 30 and 60 slots, using a uniform delay distribution, callpython examples/plot_example.pyTo compare the discovery latency of two nodes when using different distributions across a range of their scale parameters, runpython examples/compare_dists.pyTo plot the discovery latency of a clique of nodes over the node density, runpython examples/plot_density.pyTo optimize the scale parameter of the geometric distribution to a range of charging times, runpython examples/optimize_scale.pyReproduce key resultsWe used the code provided in this directory to gain the insights presented in section 2 ofour paper.
We invite you to reproduce our results with the scripts provided in thereproducibilitydirectory.
Some of the calculations take significant computing resources and require a high performance computing system with a large number of CPUs.
Package: nesneat
NEATEST: Evolving Neural Networks Through Augmenting Topologies with Evolution Strategy TrainingIt is NEAT but the weights are trained with Natural Evolution Strategy and
the weights are shared across genomes.Requirementsnumpy
cloudpickleInstallpip install nesneatOptionalmatplotlib # To draw networks
mpi4py # For parallelization
gym # For examplesUsageCheckexamplesPYTHONPATH="$(pwd):$PYTHONPATH" python examples/cartpole.py
# Or in parallel
PYTHONPATH="$(pwd):$PYTHONPATH" mpirun -np 2 python examples/cartpole.py
Package: neso
The client/server of the Tryton application platform.
A three-tiers  high-level general purpose application platform
written in Python and use SQLite as database engine.
It is the core base of an Open Source ERP.
It provides modularity, scalability and security.InstallingSee INSTALLPackage Contentsbin/Script for startup.SupportIf you encounter any problems with Tryton, please don’t hesitate to ask
questions on the Tryton bug tracker, mailing list, wiki or IRC channel:http://bugs.tryton.org/http://groups.tryton.org/http://wiki.tryton.org/irc://irc.freenode.net/trytonLicenseSee LICENSECopyrightSee COPYRIGHTFor more information please visit the Tryton web site:http://www.tryton.org/
Package: nesovetyu-com
nesovetyu_comnesovetyu_comFree software: MIT licenseDocumentation:https://nesovetyu-com.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2019-08-13)First release on PyPI.
Package: nes-py
nes-py is an NES emulator and OpenAI Gym interface for MacOS, Linux, and
Windows based on theSimpleNESemulator.InstallationThe preferred installation ofnes-pyis frompip:pipinstallnes-pyDebianMake sure you have theclang++compiler installed:sudoapt-getinstallclangWindowsYou'll need to install the Visual-Studio 17.0 tools for Windows installation.
TheVisual Studio Communitypackage provides these tools for free.UsageTo access the NES emulator from the command line use the following command.nes_py-r<path_to_rom>To print out documentation for the command line interface execute:nes_py-hControlsKeyboard KeyNES JoypadWUpALeftSDownDRightOAPBEnterStartSpaceSelectParallelism Caveatsboth thethreadingandmultiprocessingpackages are supported bynes-pywith some caveats related to rendering:renderingis notsupported from instances ofthreading.Threadrenderingissupported from instances ofmultiprocessing.Process,
butnes-pymust be imported within the process that executes the render
callDevelopmentTo design a custom environment usingnes-py, introduce new features, or fix
a bug, please refer to theWiki.
There you will find instructions for:setting up the development environmentdesigning environments based on theNESEnvclassreference material for theNESEnvAPIdocumentation for thenes_py.wrappersmoduleCartridge Mapper CompatibilityNROMMMC1 / SxROMUxROMCNROMYou can check the compatibility for each ROM in the followinglistDisclaimerThis project is provided for educational purposes only. It is not
affiliated with and has not been approved by Nintendo.
Package: ness
NessA Python datalake client.RequirementsAWS CLIInstallationpipinstallpyarrownessQuickstartimportnessdl=ness.dl(bucket="mybucket",key="mydatalake")df=dl.read("mytable")Sync# Sync all tablesdl.sync()# Sync a single tabledl.sync("mytable")# Sync and read a single tabledf=dl.read("mytable",sync=True)FormatSpecify the input data source format, the default format isparquet:importnessdl=ness.dl(bucket="mybucket",key="mydatalake",format="csv")AWS ProfileFiles are synced usingdefaultAWS profile, you can configure another one:importnessdl=ness.dl(bucket="mybucket",key="mydatalake",profile="myprofile")Command LineUsage: ness sync [OPTIONS] S3_URI

Options:
  --format TEXT   Data lake source format.
  --profile TEXT  AWS profile.
  --table TEXT    Table name to sync.
  --help          Show this message and exit.nesssyncbucket/key--tablemytable
Package: nessai
nessai: Nested Sampling with Artificial Intelligencenessai(/ˈnɛsi/): Nested Sampling with Artificial Intelligencenessaiis a nested sampling algorithm for Bayesian Inference that incorporates normalising flows. It is designed for applications where the Bayesian likelihood is computationally expensive.Installationnessaican be installed usingpip:pip install nessaior viacondaconda install -c conda-forge -c pytorch nessaiPyTorchBy default the version of PyTorch will not necessarily match the drivers on your system, to install a different version with the correct CUDA support see the PyTorch homepage for instructions:https://pytorch.org/.UsingbilbyAs ofbilbyversion 1.1.0,nessaiis now supported by default but it is still an optional requirement. See thebilbydocumentationfor installation instructions forbilbySee the examples included withnessaifor how to runnessaiviabilby.DocumentationDocumentation is available at:nessai.readthedocs.ioContributingPlease see the guidelineshere.AcknowledgementsThe core nested sampling code, model design and code for computing the posterior innessaiwas based oncpnestwith permission from the authors.The normalising flows implemented innessaiare all either directly imported fromnflowsor heavily based on it.Other code snippets that draw on existing code reference the source in their corresponding doc-strings.The authors also thank Christian Chapman-Bird, Laurence Datrier, Fergus Hayes, Jethro Linley and Simon Tait for their feedback and help finding bugs innessai.CitingIf you findnessaiuseful in your work please cite the DOI for this code and our papers:@software{nessai,author={Michael J. Williams},title={nessai: Nested Sampling with Artificial Intelligence},month=feb,year=2021,publisher={Zenodo},version={latest},doi={10.5281/zenodo.4550693},url={https://doi.org/10.5281/zenodo.4550693}}@article{Williams:2021qyt,author="Williams, Michael J. and Veitch, John and Messenger, Chris",title="{Nested sampling with normalizing flows for gravitational-wave inference}",eprint="2102.11056",archivePrefix="arXiv",primaryClass="gr-qc",doi="10.1103/PhysRevD.103.103006",journal="Phys. Rev. D",volume="103",number="10",pages="103006",year="2021"}@article{Williams:2023ppp,author="Williams, Michael J. and Veitch, John and Messenger, Chris",title="{Importance nested sampling with normalising flows}",eprint="2302.08526",archivePrefix="arXiv",primaryClass="astro-ph.IM",reportNumber="LIGO-P2200283",month="2",year="2023"}
Package: nessaid-cli
Nessaid CLI FrameworkThis package implements a grammar specification and tools to compile the grammar and use it for driving CLIs.
The CLI commands can be expressed in grammar with the support for custom tokens with suggestion and autocompletion.The grammar specification is parsed with PLY python package and the CLI objects are implemented on top of readline.
The command loop is in async mode.Requirementsasyncio: The commandline interpreter will be looping for console input in async modeply: The lex-yacc like implementation of python. Will be used for parsing the grammar specification
and tokenizing the line inputpyreadline: For windows platforms. This is the readline implementation for windows platforms
Enduser UtilitiesThis package provides two classes for CLI building. NessaidCmd is intended to work
like the standard Cmd class for simple CLI designs.
It is a stripped down sub class of the more robest NessaidCli class.NessaidCmd: The basic Cmd like tool for end user.
The CLI command handlers are defined as python methods with chosen prefix and the
grammar definitions to drive them are expressed as the method docstring.NessaidCli: The generic base class for the CLI impelemntation.
NessaidCmd is the stripped down version as an alternative for the default Cmd implementation
Package: nessai-models
nessai-modelsModels for use with the nested sampling packagenessai.Included modelsn-dimensional unit Gaussiann-dimensional HalfGaussiann-dimensional Rosenbrockn-dimensional mixture of GaussiansGaussian mixture using data to based onthis examplefromcpnestn-dimensional Egg Box based on the version inFeroz et al. 2008n-dimensional Pyramid-like modeln-dimensional Brewer likelihood (Skilling's "Staistical Model") fromBrewer et al.Linear signal plus Gaussian noise model (LinearSignal)Sinusoidal signal plus Gaussian noise model (SinusoidalSignal)Mixture of 1-dimensional distributions (MixtureOfDistributions)Requirementsnessai_modelsrequires:numpyscipynessai>=0.6.0InstallationWe recommend following theinstallation instructions fornessaiand then installingnessai_modelssince it shares all of its dependencies withnessai.nessai_modelscan be install from PyPI usingpip install nessai-modelsExample usageBelow is an example of usingnessai_modelsso configure a 4-dimensional Gaussian and then sample it usingnessai.fromnessaiimportFlowSamplerfromnessai_modelsimportGaussianmodel=Gaussian(4)fs=FlowSampler(model,output='example/')fs.run()CitingIf you usenessai_modelsin your work please cite theZenodo DOI
Package: nessclient
nessclientA python implementation/abstraction of theNess D8x / D16x Serial Interface ASCII protocolInstalling nessclientnessclientis available directly from pip:pipinstallnessclientDocumentationThe full documentation can be found atRead the DocsCLIThis package includes a CLI which uses the library to interface with the Ness Serial Interface. You can read more inthe docsTo use the CLI you must install it's dependencies by installing it with extras forcli:pip install nessclient[cli]
ness-cli --helpAPI DocumentationYou can find the full API documentationhereExamplesPlease seeExamplessection in the docs for examples. These same examples can be found as source in theexamples/directory.DevelopingPlease seeDevelopingsection in the docs for development environment setup information.
Package: nesse
nesseNab Event Shape SImulation Effort (NESSE) is a python based solid state detector simulation developed for the Nab experiment.DependenciesPlease insure the following dependencies are installed if installing nesse manually.Cython==0.29.32uproot==4.3.7numpy==1.24.3scipytqdmmatplotlibnumbah5pypandasInstallnesse can either be installed using pip or manually.To install with pippython3 -m pip install nesseTo install manually git clone and append the path to the nesse src directory like below:import sys
sys.path.append(path_to_nesse+"/src/")
import nessePlease see the tutorial notebook for more instruction on how to use nesse.
Package: nessie-recorder
Tools for Nessie Circuits energy harvesting recorderThe energy harvesting recorder records voltage and current of two energy harvesters (AC and DC) as well as accelerometer readings.
The tools in this repository are used to convert recorded data tocsvorhdffiles for analysis and further processing.
There's also a command to convert a harvesting trace to a format compatible with the Nessie Circuits SolarBox.InstallationInstall the python package using eitherpip install nessie.recorderorpipenv install nessie.recorderData extractionTo convert the fileREC_001.DATrecorded with an EH recorder to acsvoutput file:nessie-recorder extract -i REC_001.DAT -o out.csvExtracting tocsvrequires to load all recorded data into memory, which may not work for very large files.As an alternative, convert the fileREC_001.DATto anhdf5output file:nessie-recorder extract -i REC_001.DAT -o out.h5PlottingTo plot the extracted data:nessie-recorder plot -i out.csvIf your recording is very long, you won't be able to load all data into memory for plotting. If you extracted your data tohdf5, you can plot the downsampled (e.g., every 100th sample) data with:nessie-recorder plot -i out.h5 -d 100Conversion to SolarBoxYou can convert an EH recorder trace to a SolarBox trace to replay it to an energy harvesting device.
For this purpose, you will need a mapping of the SolarBox input value (0-100%) to the resulting power of a panel mounted inside.
This mapping must be formatted as acsvfile with two columns:solarboxandrecorderin percent and watts respectively.solarbox,recorder
0,8.4833230555061e-08
10,0.00768804210057344
20,0.015250790089624976
30,0.022412615156234474
40,0.029180363344797327With this mapping stored undermapping.csv, you can convert the recorder tracerecorded.csvto a SolarBox tracesolarbox.csvusing:nessie-recorder convert -i recorded.csv -o solarbox.csv -m mapping.csvExample ConfigurationThis directory also contains an example configuration file./CONFIG.INIfor use with the EH recorder. Adjust it to your needs and store it on the top level of a FAT32-formatted SD Card under the nameCONFIG.INI.
Package: ness-search
NESSNESS is an alignment-free tool for sequence search based on word embedding an approximate nearest neighbor (ANN) search. The tool is still under development and the code present in this repository is a proof of concept distributed under the GPL v3 license.Installation$ pip install ness-searchUsageCurrently the NESS CLI interface provides the following commands:ness build_modelCreates a Word2Vec model from a multi FASTA file. For DNA sequences, use--both-strands.$ ness build_model \
    --input swissprot.fasta \
    --output swissprot.modelness build_databaseSimilarly tomakeblastdb, formats a sequence database with vectors computed using a
model previously built. For DNA sequences, use--both-strands.$ ness build_database \
    --input swissprot.fasta \
    --model swissprot.model \
    --output swissprotness searchSimilarly to theblast*programs, compares a multi  FASTA file with the previously formated database.$ ness search \
    --input sequences.fasta \
    --database swissprot \
    --output hits.csvCiteKremer, FSet al(2021).NESS: an word embedding-based tool for alignment-free sequence search. Available at:https://github.com/omixlab/ness.AcknownledgementsNESS was supported by grants fromFundação de Amparo à Pesquisa do Estado do Rio Grande do Sul (FAPERGS)and is developed in partership withBiomeHub.