Saravanan666/pypi-org huggingface dataset:
Package: neml
NEML: the Nuclear Engineering material Model LibraryNEML (the Nuclear Engineering Material model Library) is a tool for creating
and running structural material models.
While it was originally developed to model high temperature nuclear reactors,
the tool is general enough to apply to most types of structural materials.The focus of NEML is on modularity and extensibility.
The library is structured so that adding a new feature to an existing material
model should be as simple as possible and require as little code as possible.NEML material models are modular -- they are built up from smaller pieces into
a complete model.
For example, a model might piece together a temperature-dependent elasticity
model, a yield surface, a flow rule, and several hardening rules.
Each of these submodels is independent of the other objects
so that, for example, switching from conventional J2 plasticity
to a J2 theory requires only a one line change in an input file,
if the model is already implemented, or a relatively small amount of coding
to add the new yield surface if it has not been implemented.
All of these objects are interchangeable.
For example, the damage, viscoplastic, and rate-independent plasticity
models all use the same yield (flow) surfaces, hardening rules, elasticity
models, and so on.As part of this philosophy, the library only requires new components
provide a few partial derivatives and NEML uses this information to assemble
the Jacobian needed to do a fully implement, backward Euler integration of the
ordinary differential equations comprising the model form and to provide
the algorithmic tangent needed to integrate the model into an implicit
finite element framework.Documentation and tutorials are availablehere.LicenseThe library is provided under an MIT license found in theLICENSEfile.The NEML distribution contains a copy of
thepybind11header library, which
has its own license contained in the pybind11 subdirectory.The NEML distribution contains a copy of
therapidxmlheader library, which
has its own license contained in the rapidxml subdirectory.Python packageThe python package version of the software available on PiPy requires:A working C++ compiler.Linkable version ofBLASandLAPACK.This version does not support multithreading or linking with external C/C++/Fortran codes.
Package: nemoa
NemoaNemoais a machine learning- and data analysis framework, that implements theCloud-Assisted Meta Programming(CAMP) paradigm.The key goal of Nemoa is to provide a long-term data analysis framework, which
seemingly integrates into existing enterprise data environments and thereby
supports collaborative data science. To achieve this goal Nemoa orchestrates
established Python frameworks likeTensorFlow®andSQLAlchemyand dynamically extends their
capabilities by community driven algorithms (e.g. forprobabilistic graphical
modeling,machine
learningandstructured
data-analysis).Thereby Nemoa allows client-side implementations to use abstractcurrently
best fitting(CBF) algorithms. During runtime the concrete implementation of
CBF algorithms are chosen server-sided by category and metric. An example for
such a metric would be the average prediction accuracy within a fixed set of
gold standard samples of the respective domain of application (e.g. latin
handwriting samples, spoken word samples, TCGA gene expression data, etc.).Nemoa isopen source, based on thePythonprogramming language and actively developed as
part of theLiquid MLframework
atFrootlab.Current Development StatusNemoa currently is inPre-Alphadevelopment stage, which immediately follows
thePlanningstage. This means, that at least some essential requirements of
Nemoa are not yet implemented.InstallationComprehensive information and installation support is provided within theonline manual. If you already have a
Python environment configured on your computer, you can install the latest
distributed version by using pip:$ pip install nemoaDocumentationThe documentation of the latest distributed version is available as anonline
manualand for download, given in the
formatsPDF,EPUBandHTML.ContributeContributors are very welcome! Feel free to report bugs and feature requests to
theissue trackerprovided by
GitHub. Currently, as the Frootlab Developers team still is growing, we do not
provide any Contribution Guide Lines to collaboration partners. However, if you
are interested to join the team, we would be glad, to receive an informalapplication.LicenseNemoa isopen sourceand available free
for any use under theGPLv3 license:© 2019 Frootlab Developers:
  Patrick Michl <patrick.michl@frootlab.org>
© 2013-2019 Patrick Michl
Package: nemo-aligner
NVIDIA NeMo-AlignerIntroductionNeMo-Aligner is a scalable toolkit for efficient model alignment. The toolkit has support for state of the art model alignment algorithms such as SteerLM, DPO and Reinforcement Learning from Human Feedback (RLHF). These algorithms enable users to align language models to be more safe, harmless and helpful. Users can do end-to-end model alignment on a wide range of model sizes and take advantage of all the parallelism techniques to ensure their model alignment is done in a performant and resource efficient manner.NeMo-Aligner toolkit is built using theNeMo Toolkitwhich allows for scaling training up to 1000s of GPUs using tensor, data and pipeline parallelism for all components of alignment. All of our checkpoints are cross compatible with the NeMo ecosystem; allowing for inference deployment and further customization.The toolkit is currently in it's early stages, and we are committed to improving the toolkit to make it easier for developers to pick and choose different alignment algorithms to build safe, helpful and reliable models.Key featuresSteerLM: Attribute Conditioned SFT as an (User-Steerable) Alternative to RLHF.Learn more at ourSteerLMandHelpSteerpapers. Try it instantly for free onNVIDIA AI PlaygroundSupervised Fine TuningReward Model TrainingReinforcement Learning from Human Feedback using thePPOAlgorithmDirect Preference Optimization as described inpaperLearn MoreDocumentationExamplesTutorialsLatest ReleaseFor the latest stable release please see thereleases page. All releases come with a pre-built container. Changes within each release will be documented inCHANGELOG.Installing your own environmentRequirementsNeMo-Aligner has the same requirements as theNeMo Toolkit Requirementswith the addition ofPyTriton.InstallationPlease follow the same steps as theNeMo Toolkit Installation Guidebut run the following after installing NeMopipinstallnemo-aligneror if you prefer to install the latest commitpipinstall.Docker ContainersTo build your own, refer to theNeMo Dockerfileand addRUN pip install nemo-alignerat the end.Future workAdd Rejection Sampling supportWe will continue improving the stability of the PPO learning phase.Improve the performance of RLHFContributingWe welcome community contributions! Please refer toCONTRIBUTING.mdfor guidelines.LicenseThis toolkit is licensed under theApache License, Version 2.0.
Package: nemo_arethusa_plugin
This repository contains a plugin for embedding Arethusa inFlask Capitains Nemo.
It was produced during the Perseids Tufts Hackathon in May 2016.The version of the Arethusa code which is used here can be found athttps://github.com/alpheios-project/arethusa/tree/nemo_arethusa_widgetIt is currently using commit 924f384.ContributorsBridget Almas ( @balmas )Frederik Baumgardt ( @fbaumgardt )Thibault Clérice ( @ponteineptique )Elijah Cooke ( @elijahjcooke )
Package: nemo-asr
NeMo ASR Collection: Neural Modules for Automatic Speech RecognitionModelsThe NeMo ASR collection currently has modules for buildingAll Jasper convolutional models:
..* Jasper DR 10x5
..* Jasper 15x5 Seperable
..* Jasper MiniJasper Encoder + Seq2seq DecoderSee the documentation and tutorials fornemo_asrhere.
Package: nemo-bldc
In drones or in robotics, brushless motors are becoming more and more common. However, choosing the right motor for the right application can be quite difficult. Indeed, understanding datasheets can be quite complexe: is a motor with a no-load speed of 5000rpm more powerful that one with the same torque, but specified for 3000rpm at max torque? How do you compare a motor with a KV of 500 rpm/V with one with a Kt of 0.5Nm/Arms? And what do these value even mean? Sometimes you might feel like nobody can answer - well now,Nemocan!Nemois aNifty Evaluator for MOtors- more practically, it is a tool to compare brushless motors (PMSM). While the choice of the "best" motor ultimately depends on the application,Nemowill help you in making a fair comparison between motors from various manufacturers, to truly understand their limit. It also offers a simulation of a basic Field Oriented Control (FOC) controller, which can be used to easily configure the gains of the various feedback loops.Let's take an example:My Actuator's pancake motors. How does the oldRMD-L-7025, equipped with a 1:6 gearbox, compare to the newerRMD-X6 1:6. Well, here are the motor's characteristics (torque-speed curve) and specs for a direct comparison:Nemocan be used to:compare motors from different manufacturers and choose the best for a given applicationobtain detailed information about a motor, like output power, efficiency, required battery current... that may not be available on the datasheetsimulate motor motion with a typical FOC driver - which can come in handy when tuning the feedback gainsmore generally, learn about brushless motors, as thefull mathematical model is detailed herePlease see theUser Manualfor more information on the software.Important note:Nemoworks by using the classical linear model of non-sallient PMSM. While this model is known to be fairly accurate (being the base of Field-Oriented Control), in practice non-linear phenomenons can alter motor performance (magnetic saturation, cogging, friction...). Also, motor parameters usually vary between one unit and another (manufacturers typically guarantee them by 10%). Thus, values from the manufacturer's datasheet may differ from those given byNemo: when in doubt, don't hesitate to ask the manufacturer about their datasheet. As always in engineering, remain cautious and plan system dimensioning with a reasonable margin of error.Installing NemoDependency: PyGObjectNemodepends on PyGObject, python bindings for the GTK library. Refer tothe PyGObject documentationfor instruction on how
to install it on your system.Python installNemois distributed thoughPyPiand can just be installed usingpip:pip install nemo_bldcYou can also install it from source by downloading this repo and running:pip install .Windows binaryFor Windows, you can simply usethis binary; you can of course also install it in a python environment by following the above instructions.
Package: nemoblock
nemoblockProject descriptionnemoblock provides utilities to generate blockMeshDicts for structured mesh generation in OpenFOAM. It manages the numbering of the points, the orientation of the surfaces and the connections between the blocks. In this way it helps the user to focus on the most important point: generating high quality meshes.The project is developed and maintained by theModel experiments groupat the Leibniz Institute for Crystal Growth (IKZ).ReferencingIf you use this code in your research, please cite our article:TODOPrerequisitesnemoblock requires Python >= 3.7. The following dependencies are installed automatically: matplotlib, numpy, scipy.If you encounter any problems with these packages try:pipinstall--upgradematplotlib
pipinstall--upgradenumpy
pipinstall--upgradescipyInstallationThe latest release can be installed using pip:pip install nemoblockUsagenemoblock follows the naming conventions in theOpenFOAM user guide:To initialize nemoblock you have to create a mesh object:importnemoblockasnbmesh=nb.Mesh()You can then create a block object with the mesh and points p0 to p7 :b1=b1=nb.Block(mesh,[0,0,0],[1,0,0],[1,1,0],[0,1,0],[0,0,1],[1,0,1],[1,1,1],[0,1,1],)Then, you can set the number of cells in x1, x2 and x3 direction and modify the grading:b1.set_number_of_cells(10,10,10)b1.grading="simpleGrading (1 1 1)"# this is the defaultWhen all the points are defined you have to "create" the block:b1.create()This creates the edges e0 to e11 that can then be modified, e.g. to form an arc:b1.e0.type="arc"b1.e0.points.append([0.5,0.3,0])If you add additional blocks you have to set the relations:b2=nb.Block(mesh)# raw blockb2.set_connection(b1,"bottom")# on top of b1# define missing pointsb2.p4=[0,0,2]b2.p5=[1,0,2]b2.p6=[1,1,2]b2.p7=[0,1,2]# set number of cellsb2.cells_x3=5# the others were derived from b1b2.create()However, this does only work if the coordinate systems of the blocks have the same orientation. In more complex cases you can use:b2.face_top=b1.face_bottom# define missing points...# set number of cellsb2.set_number_of_cells(10,10,5)# In this case you have to provide the number of cells for all directions.# Make sure that this is conforming with b1!Only use this if your mesh topology requires it, because it is prone to errors.Eventually, you can create a patch, e.g. an inlet and export your blockMeshDict:inlet=nb.Patch(mesh,"inlet inlet")inlet.add_face(b1.face_bottom)mesh.write()The resulting mesh looks like this:ExamplesExamples, e.g. with grading for boundary layers or much more complex meshes generated using pre-defined cylinders and rings, can be found in the examples directory. This includes the setup for a mesh with the following structure:Licensenemoblock is published under theGPLv3 license.AcknowledgementsThis projecthas received funding from the European Research Council (ERC) under the European Union's Horizon 2020 research and innovation programme (grant agreement No 851768).ContributionAny help to improve this package is very welcome!
Package: nemoize
nemoizeSimple Python Memoizer decorator for classes, functions, and methods.Installationnemoize is available on PyPipython3 -m pip install nemoizeOr you can install manually via the built distribution (wheel)/source dist fromPyPiorgithub.How to UseImportfromnemoizeimportmemoizeThen use the@memoizedecorator on various entities as seen belowUsing on a Class@memoizeclassTest:def__init__(self,value):self._value=value@propertydefvalue(self):returnself._valueUsing on a function@memoizedeftest_func():return"hoot"Using on an instance methodclassOwl:def__init__(self):self.food=1337pass@memoize(max_size)defeat(self,num):self.food-=numConfigurationThere are also various configuration parameters tomemoize():@memoize(max_size=13): Max number of entries to keep in the cache:@memoize(cache_exceptions=True): Also cache exceptions, so any raised Exceptions will be the exact same Exception instance:@memoize(max_size=13, cache_exceptions=True): Together@memoize(arg_hash_function=str): Changes the hash function on arg and each keyword-arg to use the str() function, which can make lists "hashable"TestingThe unit tests intest/unit/test_memoize.pyrun through various use cases of using the @memoize annotation on classes, functions, and instance methods.BenchmarkingThere is a benchmarking utility underbenchmark/that is used for benchmarking nemoize performance against other options and non-memoized scenarios.Example numbers:Benchmark test for Memoized vs Non-memoized classes with [1000] computations in their__init__() methods for [1000000] iterations
Non-memoized class creation + empty method call average time (ms): 0.01550699806213379
Memoized class creation + empty method call average time (ms): 0.0012589995861053468

Benchmark test for @memoize, non-memoized, a @simplified_memoize, and @functools.lru_cache comparison usingfunction calculating fibonacci sum for [100] fib numbers, for [10000000] iterations
@simplified_memoize fib average time (ms): 0.0001555999994277954
@memoize fib average time (ms): 4.4699978828430175e-05
@memoize(cache_exceptions=True) (to avoid delegation to functools.lru_cache) fib average time (ms): 0.00034309999942779544
@functools.lru_cache fib average time (ms): 4.440000057220459e-05
Package: nemo-library
NEMO LibraryThis library helps you with access to NEMO APIsInstallationpip install nemo_librarySourcesplease find all sources on github:https://github.com/H3rm1nat0r/nemo_libraryconfigurationplease create a file “config.ini”. This is an example for the content:[nemo_library]
nemo_url = https://enter.nemo-ai.com
tenant = <your tenant>
userid = <your userid>
password = <your password>
environment = [prod|dev|demo]MethodsProjectsgetProjectList methodReturn list of projects (as pandas Dataframe)fromnemo_libraryimportNemoLibrarynl=NemoLibrary()df=nl.getProjectList()ProjectProperty methodGet a project propertyfromnemo_libraryimportNemoLibrarynl=NemoLibrary()val=nl.ProjectProperty(projectname=None,propertyname="ExpDateTo")getImportedColumns methodGet list if imported columns of a projectfromnemo_libraryimportNemoLibraryimportpandasaspdnl=NemoLibrary()df=nl.getImportedColumns(projectname="0 SNR")setMetadataSortOrder methodSet sort order of fields in a projectfromnemo_libraryimportNemoLibraryimportpandasaspd# import field order from infozoom meta data exportdfsort=pd.read_csv("Metadaten_AUTODATA_SORT_1.csv",delimiter=";")fieldlist=dfsort["Importname"].to_list()nl=NemoLibrary()nl.setMetadataSortOrder(projectname="AUTODATA",fields=fieldlist)ReUploadFile methodReUpload a CSV file into an existing projectfromnemo_libraryimportNemoLibrarynl=NemoLibrary()nl.ReUploadFile(projectname="21 CRM",filename="./csv/hubspot.csv")ReportsLoadReport methodLoad a report from NEMO and return this as pandas dataframefromnemo_libraryimportNemoLibrarynl=NemoLibrary()df=nl.LoadReport(report_guid="b82cfed8-81a7-44e0-b3da-c76454540697")project_idOptional parameter. If you want to get reports for non-default ERP
projects. Please provide the project GUID (you can retrieve them by
running getProjectList)report_guidThis methode takes 1 mandatory parameter, the report_guid. You can find
“your” guid in NEMO meta data. Just open the definition of the report in
meta data and copy the GUID from your browser URL.The report “(SAMPLE) Replenishment Time Analysis Purchased Parts” for
example has this URL:https://enter.nemo-ai.com/nemo/metadata/report/b82cfed8-81a7-44e0-b3da-c76454540697and thus the GUID you need is then
“b82cfed8-81a7-44e0-b3da-c76454540697”max_pagesBy default all pages from the report are loaded. You can optionally
restrict the amount of data by providing max_pages parameter and you’ll
get not more than this number of pages (usually 1 page holds 20 records)ContributionsContributions are welcome! If you would like to suggest improvements or
have found a bug, please open an issue or submit a pull request.LicenseThis project is released under the Unlicense. You can find the full text
of the Unlicense in theUNLICENSEfile. This means that
the code is released into the public domain, and you are free to use,
modify, distribute, and do whatever you want with it, without any
restrictions or requirements.
Package: nemonet
Vision (beta version)Visual testing framework. Combining selenium and computer vision.VisionWhat is Vision?It is a web app testing framework that combines selenium and computer vision written in python.

There are several good selenium automation frameworks out there. Why then make another one? 
- Most of the better frameworks are not free for use.
- Most frameworks are selenium only.
- I needed a framework that is open source.
- I needed a framework that needs minimal codingGetting startedBefore installationPython is installed on your systemChrome web browser installedDownload ChromeChrome web driver installedChromeDriver - WebDriver for Chrometest if you can start the web browsertest if you can start chromedriver from commandlinebest  to install the package underpython virtual environmentinstallhttps://graphviz.orginstallGraphviz for your environmentInstall detailsInstallationpip install nemonetRun exampleopen a command promptclone following repo : git clonehttps://github.com/janrum/visiontestfiles.gitcd into visiontestfilesvision selenium-dev
Package: nemony
🧠 nemonyDeterministically encode text as mnemonic adjective-noun pairs.The same text should be identically encoded across systems. While
there are currently more than 800,000 combinations of adjective and noun,
collisions (two texts having the same mnemonic) can happen.InstallationThe easy wayInstall the pre-compiled version from PyPI:pipinstallnemonyFrom sourceClone the repository, thencdinto it. Then run:pipinstall-e.UsageCommand lineYou can use nemony to encode lines of text from a file
(the header info goes tostderr).$printf'hello\nworld'>tmp.txt
$nemonytmp.txt## MNEMO: Generate adjective-noun mnemonicsWordlistversion:fancy_telecom-Numberofadjectives:581-Numberofnouns:1450-Combinations:842450decorous_block
late_kevinOr pipe from fromstdin.$printf'hello\nworld'|nemony## MNEMO: Generate adjective-noun mnemonicsWordlistversion:fancy_telecom-Numberofadjectives:581-Numberofnouns:1450-Combinations:842450decorous_block
late_kevinYou can also run interactively to check one thing at a time.
Bear in mind that this encodes the whole text, not one line
a time.$nemony-i## MNEMO: Generate adjective-noun mnemonicsWordlistversion:fancy_telecom-Numberofadjectives:581-Numberofnouns:1450-Combinations:842450(Ctrl-Ctoexit.)Whatwouldyouliketoencode?

?>hello
decorous_block
?>world
late_kevin
?>hello\nworld
warm_dominicusage: nemony [-h] [--interactive] [--output [OUTPUT]] [input]

Encode lines of text deterministically as adjective-noun mnemonics.

positional arguments:
  input                 File to read and emit one mnemonic per line. Default STDIN.

options:
  -h, --help            show this help message and exit
  --interactive, -i     Run interactively.
  --output [OUTPUT], -o [OUTPUT]
                        Output file. Default STDOUT.Python APIYou can importnemonyand use it to encode Python objects, as
long as they can be converted to strings.>>>importnemonyasnm>>>nm.encode('world',sep='-')'late-kevin'>>>nm.encode('world',sep='-',n=5)'peppy-gabriel'>>>nm.encode(5.)'live_drum'>>>nm.encode(['hello','world'])'receding_cheese'As a convenience, you can also use the SHA-256 hashing functions
(which use Python standard libraryhashlib).>>>nm.hash('world')'486ea46224d1bb4fb680f34f7c9ad96a8f24ec88be73ea8e5a6c65260e9cb8a7'>>>nm.hash('world',n=8)'486ea462'>>>nm.hash(5.,n=8)'a19a1584'DocumentationCheck the Python API atReadTheDocs.
Package: nemos
nemosNEural MOdelS, a statistical modeling framework for neuroscience.DisclaimerThis is an alpha version, the code is in active development and the API is subject to change.SetupTo install, clone this repo and install usingpip:gitclonegit@github.com:flatironinstitute/nemos.gitcdnemos/
pipinstall-e.If you have a GPU, you may need to install jax separately to get the proper
build. The following has worked for me on a Flatiron Linux workstation:conda install jax cuda-nvcc -c conda-forge -c nvidia. Note this should be done
withoutjaxandjaxlibalready installed, so either run this before the
earlierpip installcommand or uninstall them first (pip uninstall jax jaxlib). Seejax docsfor
details (thepipinstructions did not work for me).