Saravanan666/pypi-org huggingface dataset:
Package: nox
NoxFlexible test automation with PythonDocumentation:https://nox.readthedocs.ioSource Code:https://github.com/wntrblm/noxOverviewnoxis a command-line tool that automates testing in multiple Python environments, similar totox. Unlike tox, Nox uses a standard Python file for configuration:importnox@nox.sessiondeftests(session:nox.Session)->None:session.install("pytest")session.run("pytest")@nox.sessiondeflint(session:nox.Session)->None:session.install("flake8")session.run("flake8","--import-order-style","google")InstallationNox is designed to be installed globally (not in a project virtual environment), the recommended way of doing this is viapipx, a tool designed to install python CLI programs whilst keeping them separate from your global or system python.To install Nox withpipx:pipxinstallnoxYou can also usepipin your global python:python3-mpipinstallnoxYou may want to user theuser-siteto avoid messing with your Global python install:python3-mpipinstall--usernoxUsageList all sessionsnox-l/--listRun all sessionsnoxRun a particular sessionnox-s/--sessiontestCheckout thedocsfor more! 🎉ContributingNox is an open source project and welcomes contributions of all kinds, checkout thecontributing guidefor help on how to help us out!All contributors must follow thecode of conductand be nice to one another! 😃
Package: noxcollections
noxcollectionssimple, clean, pure python collectionsnoxcollectionsis pure Python implementation of basic data structures and a
few basic algorithms operating on them.DisclaimerThis project’s main purpose is to get myself acquainted to the process of
developing a proper python package with the common tooling used for testing,
linting, type checking, and building in python.Additionally I hope to refresh and better structure my knowledge about the
implemented data structures and algorithms.For the reasons stated above this project is mainly meant for educational
purposes.If you need performance built-in packagecollectionsas well
as some other packages from PyPI will probably serve you better(due to better
optimization as well as the fact that most of them are implemented as C
extensions).GoalsFollowing goals are most important to this project:Clean, modern codeFull test coverageFully typed public APICurrent stateThe following lists contain planned features and their state current state.This package is currently before its first release.Data structures[ ] Linked lists and other data structures that can be based on them[x] Linked list[ ] Doubly linked list[x] Stack[ ] Queues[ ] Other list types[ ] Tree based structures[ ] Graphs based structuresAlgorithms[x] Search Algorithms[x] Binary search[x] Linear search[ ] Sorting Algorithms[x] Bubble sort[x] Merge sort[ ] Quick sort[ ] Graph algorithms (TBD)How to useFor use only Python(3.8+) interpreter is needed. To run test/linters/mypy
use ofPoetryis recommended. Further instructions will assume you have it
installed.InstallationInstall using pipYou can install last release version of this package fromPyPIusingpip.pipinstallnoxcollectionsUsing PoetryFirst install the package in the environment manage by Poetry:poetryinstall# build, from main repository directoryAnd then call your script from the main repository’s directory prefacing it
withpoetryfor example if your file is int same directory and as calledmain.py:poetry python main.pyTesting and lintingTesting uses thepytestpackage for testing andtoxto run the test suite
against multiple versions of Python:3.83.93.10Tox configurations also does linting (usingblackandflake8) and type
checking (usingmypy)To run all of the aforementioned tools using tox (after installing all of the
dependencies and package usingpoetry install):poetry run toxTo run those tools more selectively check thetox.inifile to check the names
of the environments you wish to run.
Package: nox-pdm
nox-pdmUsePDMinsideNoxsessionsThis package provides a drop-in replacement for thenox.sessiondecorator,
and for thenox.Sessionobject passed to user-defined session functions.
This enablessession.installto install packages at the versions specified in thepdm.lockfile.fromnox_pdmimportsession,Session@session(python=["3.10","3.9"])deftests(session:Session):# To install all packages in dependency group `tests` while using pdm.lock as constraintsession.install(".[tests]")session.run("pytest")InstallationInstallnox-pdmfrom the Python Package Index:pipinstallnox-pdmImportant:This package must be installed into the same environment that Nox is run from.
If you installed Nox usingpipx,
use the following command to install this package into the same environment:pipxinjectnoxnox-pdmRequirementsPython 3.9+PDM >= 2.12.0You need to have aPDMinstallation on your system. It does not have to be in the
same environment, but at the very least running the commandpdmshould work.nox-pdmuses PDM via its command-line interface.CreditsThis project was inspired by Claudio Jolowicz'shttps://pypi.org/project/nox-poetry.
Package: nox-py2
Nox - Flexible test automation for Pythonnoxis a command-line tool that automates testing in multiple Python
environments, similar totox. Unlike tox, Nox uses a standard Python
file for configuration.The latest documentation is available onRead the Docs.The source code is available onGitHub.Python 2 VersionThis is a custom version of nox which supports python 2.
It was created for a specific project’s needs,salt, because on some distributions where it’s tested
there’s either no Python 3 support or not a recent enough version of Python 3.
Package: nox_tools
nox-toolsPredefined sessions fornoxTo use these sessions, just install nox-tools, import them in your noxfile.py
and either set config.sessions to a list with the ones you want or manually
mark each one as a session using nox.session. You can also configure their
behavior by setting the config object's attributes.fromnox_toolsimportconfig,tests,typingconfig.module='my_module_name'config.sessions=[tests,typing]You can find out how to use each session and the config object by reading thedocstrings
Package: noyainrain.micro
microToolkit for social micro web apps.For a quick introduction on how to build an application with micro, have a look at the included
example inhello.RequirementsThe following software is required and must be set up on your system:Python >= 3.9Node.js >= 12.21Redis >= 6.0micro should work on anyPOSIXsystem.Installing dependenciesTo install the dependencies for micro, type:makedepsBrowser supportmicro supports the latest version of popular browsers (i.e. Chrome, Edge, Firefox and Safari; seehttp://caniuse.com/).Deprecation policyFeatures marked as deprecated are removed after a period of six months.BoilerplateTheboilerplatedirectory contains base files for any micro app repository. They are not required,
but may come in handy when bootstrapping a new project.Simply copy the files fromboilerplateover to the new repository and substitute all place holders
(with curly braces, like{name}). Over time, extend the files as needed with app-specific details.Public domain componentsWhile micro is covered by theLGPL, the following modules
are released into the public domain:jsonredisratelimitwebapibind.jskeyboard.jsContributorsSven James <sven AT inrain.org>Horacio Lisdero <lisderoh AT gmail.com>Niklas Meinzer <github AT niklas-meinzer.de>Copyright (C) 2021 micro contributors
Package: noyaki
noyakiConverts character span label information to tokenized text-based label information.Installation$pipinstallnoyakiUsagePass the tokenized text and label information as arguments to the convert function.importnoyakilabel_list=noyaki.convert(['明日','は','田中','さん','に','会う'],[[3,5,'PERSON']])print(label_list)# ['O', 'O', 'U-PERSON', 'O', 'O', 'O']If you want to remove the subword symbol (eg. ##), specify thesubwordargument.importnoyakilabel_list=noyaki.convert(['明日','は','田','##中','さん','に','会う'],[[3,5,'PERSON']],subword="##")print(label_list)# ['O', 'O', 'B-PERSON', 'L-PERSON', 'O', 'O', 'O']If you want to use IOB2 tag format, specify theschemeargument.importnoyakilabel_list=noyaki.convert(['明日','は','田','##中','さん','に','会う'],[[3,5,'PERSON']],scheme="IOB2")print(label_list)# ['O', 'O', 'B-PERSON', 'I-PERSON', 'O', 'O', 'O']NoteOnly Japanese is supported.supported tag formats are follow:BILOUIOB2
Package: noy-black
This is a monkey patch of black (https://github.com/psf/black) to give it the
ability to understand the noseOfYeti (http://noseofyeti.readthedocs.io)speccoding.To use it:$ pip install noy_black
$ noy_black file_to_format.pyWhere all the arguments are the same as the normal black command.It will even use noseOfYeti to tokenize the original and the formatted files to
check that the ast is equivalent before and after formatting with black.CaveatsBecauseit,ignore,describe,before_eachandafter_eachare special keywords only for noseOfYeti, you can still use these
words as variable names. However you cannot start a line with any of these
keywords or black will get confused.For example:# This will confuse blackdescribe=1# This will not confuse blackone,describe=1,2# this will also not confuse blackforitin[1,2]:print(it)# but this willit=1Also, this works by defining the whole python grammar plus some extra grammar
so new versions of black will mean I have to update my version of the Grammar.Doesn’t work anymore!Since the stable version of black now comes as binary .so files, the hack that
makes this work no longer works and you need to do something like:python -m pip install --no-binary black noy_blackChangelog0.3.4 - 30 April 2022Upgrade black0.3.3 - 17 February 2022Support typed parameters for it/ignore blocks0.3.2 - 17 February 2022Fixes for new version of black0.3.1 - 16 February 2022Upgrade black to 22.1.00.3.0 - 6 November 2021Upgrade black to 21.10b00.2.1 - 22 November 2020Upgrade version of black to use with this0.2.0 - 22 March 2020Now only support noseOfYeti>=2.0.00.1.5 - 9 November 2019Make it compatible with python3.60.1.4 - 9 November 2019Make it compatible with python3.80.1.3 - 30 October 2019Initial release
Package: nozdormu
Python benchmarking for humans and dragons.FeaturesUnittest-style benchmark setup (TestCase -> BenchBatch)setUp/tearDownare excluded from timingPrecise even for very fast benchmarks by running them for at least 1ms
or 16 times, whichever takes longerTiming down to the nanosecondBenchmarks in a batch are run interleaved to reduce jitter from random loadManual GC to prevent interference with the benchmarksResults are saved into a human-readable json file and used as baseline for
future testsJust a few milliseconds overheadRequirementsPython 2.6+ / 3.2+Usage exampleimportnozdormuclassMyBenchBatch(nozdormu.BenchBatch):defbench_one(self):passdefbench_two(self):passclassAnActualBenchBatch(nozdormu.BenchBatch):defsetUp(self):importrandomself.r=randomdefbench_list_creation(self):l=[]foriinrange(100):l.append(i)defbench_random_addition(self):l=[]foriinrange(100):l.append(self.r.randint(0,100))defbench_import_math(self):importmathif__name__=='__main__':nozdormu.main()yieldsStarting benchmark session

  Running Batch: AnActualBenchBatch
    bench_random_addition: 152μs (2ms / 16 runs) (-6μs / 3.6%)
    bench_list_creation: 8μs (1ms / 127 runs) (-85ns / 1.1%)
    bench_import_math: 954ns (1ms / 1049 runs) (new)
  Batch finished, time: 12ms

  Running Batch: MyBenchBatch
    bench_one: 236ns (1ms / 4243 runs) (-13ns / 5.4%)
    bench_two: 232ns (1ms / 4305 runs) (-6ns / 2.7%)
  Batch finished, time: 9ms

Benchmarking finished
2 batches, 5 benchmarks
total time: 23mswith some Cucumber-inspired colouring if your terminal supports that.UsageAs you can see above, there are few things for you to do. The general structure
is very similar to unittests. Firstimport nozdormu, then subclassnozdormu.BenchBatchas often as you need to. Each batch can hold as many
benchmarks as you need it to.To get executed, benchmarks have to start with ‘bench’ (like unittests have to
start with ‘test’), and just like in unittests, you can override the class
methodssetUpandtearDownfor preparations and/or mocking. Both these
functions are run before and after each benchmark execution and will be
excluded from the benchmark timing (but included in the total time).Benchmarks that take less than 1ms will be executed repeatedly until they
accumulate at least 1ms of total runtime. This happens on a per-batch basis
and the benchmarks of a batch will rotate until they all ran long enough. This
should reduce jitter from other system load for these extremely fast
benchmarks.AcknowledgementsIdeas and inspiration by:Python’s unittest and timeit modulesGRB’s readygoCucumber
Package: nozomi
NozomiNozomi is a collection of Python protocols that, when implemented, give life to a web application or HTTP Application Programming Interface (API).State of playNozomi is a distillation of concepts developed in the production of the Amatino API and web application. It is a work in progress, and should not yet be used by anyone for anything.To be notified when Nozomi is ready for production use, signup to the Amatino newsletter:https://amatino.io/newsletter
Package: nozomipy-async
NozomiPy-AsyncAsync nozomi.la API for Python3.NozomiPy-Async is an Async Python3 library for nozomi.la API.NozomiPy-Async also provides a commandline tool to download images and tags from nozomi.la.Based on Python-Nozomi:https://github.com/Alfa-Q/python-nozomiInstallpip install nozomipy-asyncImport packagesfromnozomipy.async_apiimportapiAPI UsagesAPI initimportasynciofromnozomipy.async_apiimportapinozomi_api=api(semaphore=8,proxy="http://127.0.0.1:1080")Download images# The tags that the posts retrieved must containpositive_tags=['veigar','wallpaper']# Gets all posts with the tags 'veigar', 'wallpaper'posts=awaitnozomi_api.get_posts()# download all imagesawaitasyncio.gather(*[download_img_tags(post,path)forpostinposts])Create datasetDownload images and tags during a period to a folder named with positive tags.nozomipy--path"./"--positive_tags'miyase_mahiro'--start_date2022-02-22--end_date2022-01-22--num_process=8--proxyhttp://127.0.0.1:7890
Package: np2mcpl
np2mcplnp2mcpl is a low-key tool to help write mcpl-files directly from numpy-arrays.Build/Install/UseMake sure you have installed the MCPL-library (and NumPy)Build the python/c module:python setup.py buildAdd the build directory to PYTHONPATHorrun:python setup.py installIn your python script:import np2mcplCreate a numpy array and save it. E.g. :np2mcpl.save("output",M)Notes and limitationsnp2mcpl takes as input a 2D NumPy array with 10 or 13 columns, where the columns are assumed to be:PDG-code  x y z   ux uy uz   t e_kin weight    [ px py pz ]where the PDG-code denotes which kind of particle it is, e.g. 2112 for neutrons, 22 for photon, ... as documented here:Particle Numbering SchemeThe vector ux,uy,uz must have unit length. The optional vector px,py,pz is the polarisation vector associated with the Monte Carlo-particle.Units follow the MCPL-standard. I.e. x,y,z in cm, e_kin in MeV, t in ms.The input array is expected to be made of floating point numbers (including the PDG-code) in either double or single precision. If the numpy array is in single precision, this will be reflected in the mcpl-file.
Package: np3
NP3A fast python library to load mp3 data intoNumPyarrays.It is based on lieff'sminimp3Installationpip install np3Usageimportnp3mp3=np3.MP3(path="/my/mp3/file")# orwithopen("/path/to/file.mp3")asmp3_fh:mp3=np3.MP3(file=mp3_fh)# ordata:bytes=obtain_mp3_data()mp3=np3.MP3(data=data)print(f"Channels:{mp3.channels}")print(f"Sampling rate:{mp3.hz}Hz")length=len(mp3.samples[0])/mp3.hzprint(f"Length:{length:.1f}seconds")Threaded performanceGILis released before
decoding starts. On multi core machines this brings additional performance
when decoding in separate threads. While decoding a single file does not
parallelise, other python threads can continue working while the file is
being processed. Where multiple files need decoding this performance gain
becomes particularly significant.fromconcurrent.futuresimportThreadPoolExecutorfiles=["/path/to/file1.mp3","/path/to/file2.mp3",...]withThreadPoolExecutor()asexecutor:mp3s=executor.map(lambdap:np3.MP3(path=p),files,)
Package: npaes
npaesAdvanced Encryption Standard (AES) NumPy implementation.Warning: incomplete & not yet suitable for production use.See the "Caution" section below.SupportsPython 2.7 | 3.5 | 3.6 | 3.7Latest ReleasePackage StatusLicenseThis package implements the Advanced Encryption Standard (AES) as specified in Federal Information Processing Standards Publication 197 ("FIPS197"):https://csrc.nist.gov/publications/detail/fips/197/finalThis implementation is based entirely and solely on FIPS197.  The tests intests/test_npaes.pyuse the full set of example vectors from Appendix A, B, and C of FIPS197.npaessupports AES-128, AES-192, and AES-256.Its sole dependencies is NumPy.  It does not use OpenSSL or any other C libraries besides the portions of NumPy that are implemented in C.Additional technical notes can be found in the docstring ofnpaes/__init__.py.CautionThis package is incomplete.  While the raw encryption and decryption are fully tested using the FIPS197 example vectors, it is incomplete for the following reasons:It does not allow you to specify aninitialization vector(IV).It does not allow you to specify ablock mode.It is optimized in most places but not all, and has little to no chance of ever being as fast as the optimized ANSI C version in OpenSSL.Basic UsageimportosfromnpaesimportAES# Key must be bytes type and 128, 192, or 256 bits# Or use hashlib.sha256() for an off-length keykey=os.urandom(32)# 256-bit key# Your plaintext length must be bytes and a multiple of 16 lengthmsg=b"a secret message goes here"+6*b"\x03"cipher=AES(key)ciphertext=cipher.encrypt(msg)print(ciphertext)# b'a\x85cna\xc2\xeeu\xe9S\xdf\xabE\x0c\xda\xf4\x19\x11\xa3!\xdd\x96-\x85\x10f\xd4\x18;s%\x81'print(cipher.decrypt(ciphertext))# b'a secret message goes here\x03\x03\x03\x03\x03\x03'
Package: nparray
nparrayHigh-Level Wrappers for Building and Manipulating Numpy ArraysCreate numpy arrays (via arange, linspace, etc) and manipulate the creation arguments at any time.  The created object acts as a numpy array but only stores the input parameters until its value is accessed.Read thelatest documentation on readthedocsorbrowse the current documentation.Dependenciesnparrayrequires the following dependencies:python 2.7+ or 3.6+numpy 1.10+collections (should be standard python module)and the following optional dependencies:astropy 1.0+ (required for units support)You can see theTravis testing matrixfor
details on what exact versions have been tested and ensured to work.  If you run
into any issues with dependencies, pleasesubmit an issue.Installationnparrayis available viapip:pipinstallnparrayAlternatively, to install from source, use the standard python setup.py commands.To install globally:pythonsetup.pybuild
sudopythonsetup.pyinstallOr to install locally:pythonsetup.pybuild
pythonsetup.pyinstall--userBasic Usagenparrayis imported as a python module:import nparrayRead thelatest documentation on readthedocsorbrowse the current documentation.ContributorsKyle ConroyContributions are welcome!  Feel free to file an issue or fork and create a pull-request.
Package: nparray2pil
nparray2pilA PyPi module allowing the user to convert a numpy array into a PIL image.How does it work?Use import nparray2pil to get access to the convert functions:fromnparray2pilimportconvertand then convert:convert(myArray)Why nparray2pilconvertfrom nparray2pil works efficiently and is a very simple and convenient abstraction of an otherwise difficult task.###Exampleconvert(myArray)InstallationOn bash:$pipinstallnparray2pilOn windows:python -m pip install nparray2pilUsageContributingContributingFork it (https://github.com/)Create your feature branch (git checkout -b my-new-feature)Commit your changes (git commit -am 'Add some feature')Push to the branch (git push origin my-new-feature)Make sure that the script does not have errors or warningsCreate a new Pull RequestLicenseThis tool is open source under theMIT Licenseterms.[Back To Top]
Package: nparse
# nbparsenbparse is a library for english learners, who struggle with reading notebooks.# Usage` $ nbparse <notebook which youwant>.ipynb`And then<notebook which you want>.mdand<notebook which you want>.pyis overwritten automatically.I think it is more lighter to read i.e. more legible.# MotivationI want to enjoy Kaggle, but it’s too difficult to read notebook from scratch.Especially in Kaggle, public notebooks are very useful but it is too long for me to read one time.In addition to this, I use no-high spec PC and I’m not good at some libraries.Therefore, I would like to the following:I want to make notebook lighterit’s ok to use no-high spec PCI want to make the history which I read easier.in order tomemorize phrases or wordsto write down the usage of library.
Package: npasync
npasyncDescription:A wrapper package for python asynchronous programmingAuthor: Nopporn PhantaweeVersion note2022.7.001: First release
2022.7.002: Updated Readme.mdInstallationpip install npasync==2022.7.1Usage sample# create a Python file with the content below.fromnpasyncimportNPAsyncif__name__=="__main__":n=NPAsync()base_url="https://pokeapi.co/api/v2/pokemon/{}"urls=[base_url.format(x)forxinrange(1,21)]output=n.request_get(urls=urls)print(f"Total output is:{len(output)}")print(f"Showing the name of each Pokemon(parsed)")foriteminoutput:print(f"{item[0]['name']}")
Package: npat
NPATNPAT (nuclear physics analysis tools) is a python toolkit developed to aid in the analysis of experimental nuclear data.The primary application for NPAT is activation analysis, with specific utilities developed for stacked-target, charged-particle activation analysis.
However, the convenient python interface to nuclear decay data and a range of cross section libraries makes NPAT more generally useful in the nuclear sciences.FeaturesNPAT features the following classes to aid in data analysis:Spectrum - Peak fitting for HPGe detector data.Calibration - Energy & efficiency calibration tool (for HPGe detectors).Ziegler - Stacked-target energy loss characterization.DecayChain - General purpose Bateman equation solver.Isotope - Isotopic and decay data.Reaction - Cross sections from multiple libraries.Library - Tool for searching and retrieving cross sections from multiple libraries.More detail can be found in theUser's Guideand theAPI.Quick InstallNPAT is available through thePython Package index, which allows installation using Python's standard command line utilitypip.  Assuming Python and Pip are installed already, you can install NPAT with the command:pip install --user npator:python -m pip install --user npatDetailed installation instructions and troubleshooting can be found in the NPATdocumentation.
Package: np-audio-control
np_audio_controlFor use on internal Allen Institute networkTools for remote control of Windows system audio on Mindscope Neuropixels and Behavior rigs.Uses SetVol v3.4 (https://www.rlatour.com/setvol/)Installpython-mpipinstallnp_audio_controlBasic usage>>>fromnp_audio_controlimportmute,unmute,set_volume,get_volume>>>host='W10LTPC2BC51P'# interact with default audio device>>>mute(host)>>>unmute(host)>>>set_volume(50,host)>>>get_volume(host)50# interact with specific device (see SetVol `device name` argument)>>>device='Speakers (Realtek USB2.0 Audio)'>>>mute(host,device)>>>set_volume(50,host,device)# send any command to SetVol>>>fromnp_audio_controlimportsend_setvol_cmd>>>send_setvol_cmd(host,'beep')