Saravanan666/pypi-org huggingface dataset:
Package: napari-zulip
napari-zulipA simple plugin for interacting with Zulip from napari.InstallationYou can installnapari-zulipviapip:pip install napari-zulipTo install latest development version :pip install git+https://github.com/kephale/napari-zulip.gitSetting it upThe plugin is going to look for a file in<home directory>/.zulip.d/napari.zulipchat.com.zuliprc.If you want to use this on a different zulip then adjust thenapari.zulipchat.comto whatever the correct domain should be.How to generate a.zuliprcfileIn the Zulip app:SelectMenuSelectPersonal settingsSelectAccount & privacyClick onShow/change your API keyEnter your passwordClickDownload .zuliprcSave the file as<home directory>/.zulip.d/napari.zulipchat.com.zuliprc(or change the domain name if using a different Zulip server)ContributingContributions are very welcome. Tests can be run withtox, please ensure
the coverage at least stays the same before you submit a pull request.LicenseDistributed under the terms of theBSD-3license,
"napari-zulip" is free and open source softwareIssuesIf you encounter any problems, pleasefile an issuealong with a detailed description.
Package: napatrackmater
NapaTrackMaterNapari Visualization tool for Trackmate > 6.0 XML files for 3D + time tracks.Thiscapedpackage was generated withCookiecutterusing@caped'scookiecutter-templatetemplate.InstallationYou can installNapaTrackMaterviapip:pip install NapaTrackMaterTo install latest development version :pip install git+https://github.com/Kapoorlabs-CAPED/NapaTrackMater.gitContributingContributions are very welcome. Tests can be run withtox, please ensure
the coverage at least stays the same before you submit a pull request.LicenseDistributed under the terms of theBSD-3license,
"NapaTrackMater" is free and open source softwareIssuesIf you encounter any problems, pleasefile an issuealong with a detailed description.AuthorsVarun Kapoorrandomaccessiblekapoor@gmail.comMari TolonenJakub Sedzinski
Package: napf
napfnanoflannwrappers for python and maybe fortran.pythonAsnanoflannoffers template classes, separate classes are implemented innapffor each{datatype, data dimension, distance metric}. All the search functions are equipped with multi-thread execution. Usesnumpy.ndarrayfor data input and output.
Currently, the combinations of following options are supported:data type: {double,float,int,long}(corresponds to {np.float64, np.float32, np.int32, np.int64})data dimension: {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20}distance metric: {L1,L2}
Note that functions return squared distances, when you use theL2metric.quick startinstall with pip:pip install --upgrade pip
pip install napfNote: in case your system requires a dynamic build, you need a c++11 compatible c++ compiler. To make sure a correct compiler is chosen, setexport CC=<your-c-compiler> CXX=<your-c++-compiler>importnapfimportnumpyasnpdata=<datain2Darray>queries=<querypointsin2Darray>kdt=napf.KDT(tree_data=data,metric=1)indices,distances=kdt.knn_search(queries=queries,kneighbors=3,nthread=4,)...fortranmaybe...DocumentationThis package uses asphinxbased documentation. An online version of the documentation can be found atnapf - documentation.If you want to build the documentation yourself use the following commands in the package root directory.pipinstall-r./docs/requirements.txt
sphinx-build-W-bhtmldocs/sourcedocs/build-jautoYou will find the documentation in the docs/build folder.
Package: napi
napinapi is an abstract syntax tree transformer to simplifyNumPyarray
operations.  In IPython, for example, you can use the following magic:In [1]: import napi

In [2]: %napi
napi ast transformer is turned ONto enable evaluation of the following expression:In [3] from numpy import *

In [4] 0 <= arange(6) < 6 and True
Out[4]: array([ True,  True,  True,  True,  True,  True], dtype=bool)Installationnapiworks with Python 2.7, 3.2 and later.$ pip install -U napiDocs & SourceDocs:http://napi.rtfd.orgSource:https://github.com/abakan/napiLicensenapiis available under MIT License.
Package: napi-py
napi-pyCLI tool for downloading subtitles from napiprojekt.pl, fork ofgabrys/napi.pyprerequisitesPython 3.6 or neweron Linux,python3-devpackage:for Debian-based systems, usesudo apt-get install python3-devinstallationpip install napi-pyfor user-wide installationusage as CLI toolnapi-py ~/Downloads/MyMovie.mp4will download and save subtitles under~/Downloads/MyMovie.srtusage as libfromnapiimportNapiPymovie_path="~/Downloads/MyMovie.mp4"napi=NapiPy()movie_hash=napi.calc_hash(movie_path)source_encoding,target_encoding,tmp_file=napi.download_subs(movie_hash)subs_path=napi.move_subs_to_movie(tmp_file,movie_path)print(subs_path)in case of issuesif there are no subs for your movie, there's still hope:open the movie web page onnapiprojekt.plin your browser, as in example:https://www.napiprojekt.pl/napisy1,1,1-dla-55534-Z%C5%82odziejaszki-(2018)choose subtitles that might match your movie, right-click them and select "Copy link" on link containing hash, which looks like thisnapiprojekt:96edd6537d9852a51cbdd5b64fee9194use flag--hash YOURHASHin this tool, i.e.--hash 96edd6537d9852a51cbdd5b64fee9194or--hash napiprojekt:96edd6537d9852a51cbdd5b64fee9194developmentmake configinstallsvenvunder.venv/napi-pymake testruns testsmake buildcreates installable package
Package: napkinxc
napkinXCnapkinXC is an extremely simple and fast library for extreme multi-class and multi-label classification,
that focus on implementing various methods for Probabilistic Label Trees.
It allows training a classifier for very large datasets in just a few lines of code with minimal resources.Right now, napkinXC implements the following features both in Python and C++:Probabilistic Label Trees (PLTs) and Hierarchical softmax (HSM),different types of inference methods (top-k, above a given threshold, etc.),fast prediction with labels weight, e.g., propensity scores,efficient online F-measure optimization (OFO) procedure,different tree building methods, including hierarchical k-means clustering method,training of tree nodesupport for custom tree structures, and node weights,helpers to download and load data fromXML Repository,helpers to measure performance (precision@k, recall@k, nDCG@k, propensity-scored precision@k, and more).Please note that this library is still under development and also serves as a base for experiments.
API may not be compatible between releases and some of the experimental features may not be documented.
Do not hesitate to open an issue in case of a question or problem!The napkinXC is distributed under the MIT license.
All contributions to the project are welcome!Python Quick Start and DocumentationInstall via pip:pip install napkinxcWe provide precompiled wheels for many Linux distros, macOS, and Windows for Python 3.7+.
In case there is no wheel for your os, it will be quickly compiled from the source.
Compilation from source requires modern C++17 compiler, CMake, Git, and Python 3.7+ installed.The latest (master) version can be installed directly from the GitHub repository (not recommended):pip install git+https://github.com/mwydmuch/napkinXC.gitA minimal example of usage:from napkinxc.datasets import load_dataset
from napkinxc.models import PLT
from napkinxc.measures import precision_at_k

X_train, Y_train = load_dataset("eurlex-4k", "train")
X_test, Y_test = load_dataset("eurlex-4k", "test")
plt = PLT("eurlex-model")
plt.fit(X_train, Y_train)
Y_pred = plt.predict(X_test, top_k=1)
print(precision_at_k(Y_test, Y_pred, k=1))More examples can be found underpython/examples directory,
and napkinXC's documentation is available athttps://napkinxc.readthedocs.io.ExecutablenapkinXC can also be used as executable to train and evaluate models using data in LIBSVM format.
Seedocumentationfor more details.References and acknowledgmentsThis library implements methods from the following papers (seeexperimentsdirectory for scripts to replicate the results):Probabilistic Label Trees for Extreme Multi-label ClassificationOnline probabilistic label treesPropensity-scored Probabilistic Label TreesEfficient Algorithms for Set-Valued Prediction in Multi-Class ClassificationAnother implementation of PLT model is available inextremeTextlibrary,
that implements approach described in thisNeurIPS paper.
Package: naplib
naplib-pythonTools and functions for neural acoustic data processing and analysis in python. The documentation can be acccessed at the link below. It contains the API reference as well as example notebooks.DocumentationExamplesChangelogInstallationnaplib-python is available on PyPi. To install or update this package with pip, run the following command:pipinstallnaplibTo upgrade the version, run:pipinstall--upgradenaplibAPIThe basic data structure for storing neural recording data is theDataobject, which contains neural recordings and other variables associated with different trials such as stimuli and other metadata. Examples of loading and using this data structure can be found in the documentation and the docs/examples/ folder.DataStructure SchematicContributionsnaplib-python is built by theNeural Acoustic Processing Labat Columbia University. We primarily use it for processing neural data coming from electrocorticography (ECoG) and electroencephalography (EEG) along with paired audio stimuli in order to study the auditory cortex. You are free to use the software according to its license, and we welcome contributions if you would like to propose changes, additions, or fixes. See ourcontribution guidefor more details.Citing naplib-pythonIf you findnaplib-pythonuseful for your research, please cite the following paper (link):Gavin Mischler, Vinay Raghavan, Menoua Keshishian, & Nima Mesgarani (2023). naplib-python: Neural acoustic data processing and analysis tools in python. Software Impacts, 17, 100541.BacklogThe following items are ToDo items on the backlog:Look into data parallelization methods for the Data object and associated methodsConsider making the Data object adataclassImplement functionality to write Data objects to MATLAB formats (possibly EEGLab formats)
Package: napoleon2html
napoleon2htmlThis project contains functions that encapsulate tranlation of Sphinx orNapoleondocstrings to HTML.DocumentationThere are three function, that can be used:napoleon_to_sphinx(),sphinx_to_html()andnapoleon_to_html().napoleon_to_sphinx()This function can take documentation inNapoleonformat and translate it to Sphinx.Usage:napoleon2html.napoleon_to_sphinx("""
    Description of function

    Args:
        argument (str): Description of argument.

    Returns:
        int: Description of return.
""")Output:Description of function

:Parameters: **argument** (*str*) --
             Description of argument.

:returns: *int* --
          Description of return.sphinx_to_html()Then there is thesphinx_to_html(), which converts string in Sphinx format to HTML:napoleon2html.sphinx_to_html("""
    Description of function

    :Parameters: **argument** (*str*) --
                 Description of argument.

    :returns: *int* --
              Description of return.
""")Output:<blockquote>
<p>Description of function</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><strong>argument</strong> (<em>str</em>) --
Description of argument.</td>
</tr>
<tr class="field"><th class="field-name">returns:</th><td class="field-body"><em>int</em> --
Description of return.</td>
</tr>
</tbody>
</table>
</blockquote>napoleon_to_html()Last function isnapoleon_to_html(), which wraps the previous two.Changelog0.2.0Fixed bug in MANIFEST.in.0.1.0Project created.
Package: napolipy
napolipyNapoli Unicode Logo generatorNOTE: Not affiliated withSocietà Sportiva Calcio NapoliThe original logo is distributed following the directions of theCreative Commons license v4.0InstallationFrom githubgitclonehttps://github.com/TheDarkBug/napolipy.gitpipinstall./napolipyFrom PyPIPyPI pagepython-mpipinstallnapolipy
Package: napper
# napperA REST framework for asyncio.Currently in experimental stage. Use at your own risk.importasynciofromnapperimportapisasyncdefgetstargazers():"""Print the most popular repository of the authors of
    the most recent gists from github."""withapis.github()asgithub:gists=github.gists.get()asyncforgistingists:try:repo=awaitgist.owner.repos_url.get()[0]exceptAttributeError:print("{0.id}: Gist has no owner".format(gist))continueexceptIndexError:print("{0.id}:{0.owner.login}has no repositories".format(gist))continueprint("{0.id}:{0.owner.login}{1.name}{1.stargazers_count}".format(gist,repo))loop=asyncio.get_event_loop()loop.run_until_complete(getstargazers())
Package: napping
nappingControl point mapping and coordinate transformation using napariInstallationYou can installnappingviapip:pip install nappingTo install latest development version:pip install git+https://github.com/BodenmillerGroup/napping.gitUsageRunnappingfor control point mapping and coordinate transformationAuthorsCreated and maintained by Jonas Windhagerjonas.windhager@uzh.chContributingContributingChangelogChangelogLicenseMIT
Package: nap-plot-tools
nap-plot-toolsA NAPari PLOTter TOOLbar and tools for additional functionalities. Based on PyQt.Jump to IntallationUsageInstallationYou can installnap-plot-toolsviapip. Follow these steps from a terminal.Installnap-plot-toolsviapip:pip install nap-plot-toolsAlternatively, install latest development version with :pip install git+https://github.com/zoccoler/nap-plot-tools.gitContributingContributions are very welcome. Tests can be run with [tox], please ensure
the coverage at least stays the same before you submit a pull request.LicenseDistributed under the terms of theBSD-3license,
"nap-plot-tools" is free and open source softwareIssuesIf you encounter any problems, pleasefile an issuealong with a detailed description.
Package: naps
Building Blocks & Tools for FPGA Design with Python &nMigen.
Mostly a place to experiment and figure out how to build things.
Also the incubator for the future AXIOM Beta camera gateware & the home of the current AXIOM micro gateware.This repo contains:Prototypes of the upcoming nmigen data typesPackedStructandInterface(here calledBundle) (insrc/lib/data_structure/)A stream Abstraction with various building Blocks: (insrc/lib/stream/)FIFOsA gearbox for changing the widthHelpers for building other Stream coresMiscellaneous Debug and Inspection toolsvarious nMigen cores (insrc/lib/) for:AXI and AXI Lite including a Buffer reader and WriterA CSR bank that can be wired to an AXI busHDMI (currently the DVI subset; derived from Litevideo)A HISPI reciever (for the use with aptina / onsemi image sensors)A core for streaming data over USB3 using the ft601Some utility video processing (like debayering)…tools for gluing together SOCs (currently supports the Xilinx Zynq and JTAG based plattoforms) insrc/soc/Making heavy use of nMigen Platform abstractions (wrapping existing plattforms)Provides a bus agnostic way to describe (low speed) peripheralsEmits Python code that can be used to access the designs CSRs (“pydriver”)Generate devicetree overlays for loading linux device driverspack “fatbitstreams” that bundle setup logic, drivers and the bitstreamplatform definitions for both the AXIOM Beta and the AXIOM Micro insrc/devices/a variety of other smaller half-working experiments insrc/experiments/linux framebuffer HDMI outputUSB3 Plugin module gateware (wip)AXIOM micro camera gateware (wip)test gateware to test connectors for their ability to transmit high speed data (via a loopback test)test gateware for the axi writer & reader
Package: naps-track
NAPS (NAPS is ArUco Plus SLEAP)NAPS is a tool for researchers with two goals: (1) to quantify animal behavior over a long timescale and high resolution, with minimal human bias, and (2) to track the behavior of individuals with a high level of identity-persistence. This could be of use to researchers studying social network analysis, animal communication, task specialization, or gene-by-environment interactions. By combining deep-learning based pose estimation software with easily read and minimally invasive fiducial markers (“tags”), we provide an easy-to-use solution for producing high-quality, high-dimensional behavioral data.DocumentationNAPS documentation can be found atnaps.rtfd.io.FeaturesEasy, direct installation across platformsBuilt directly on top ofOpenCVandSLEAPwith a modular, extensible codebaseFlexible API that allows drop in of different methods for marker identificationGetting NAPSEasy installconda(Windows/Linux):condacreate-nnapsnaps-track-ckocherlab-csleap-cnvidia-cconda-forgepip(any OS):pipinstallnaps-trackReferencesManuscript:https://doi.org/10.1101/2022.12.07.518416If you use NAPS in your research, please cite:BibTeX:@article{wolf2022naps,
   title={NAPS: Integrating pose estimation and tag-based tracking},
   author={Wolf, Scott W and Ruttenberg, Dee M and Knapp, Daniel Y and Webb, Andrew E and Traniello, Ian M and McKenzie-Smith, Grace C and Leheny, Sophie A and Shaevitz, Joshua W and Kocher, Sarah D},
   journal={bioRxiv},
   year={2022},
   publisher={Cold Spring Harbor Laboratory}
}IssuesIssues with NAPS?Check thedocs.Search theissues on GitHubor open a new one.ContributorsScott Wolf, Lewis-Sigler Institute for Integrative Genomics, Princeton UniversityDee Ruttenberg, Lewis-Sigler Institute for Integrative Genomics, Princeton UniversityDaniel Knapp, Department of Physics, Princeton UniversityAndrew Webb, Department of Ecology and Evolutionary Biology and Lewis-Sigler Institute for Integrative Genomics, Princeton UniversityIan Traniello, Lewis-Sigler Institute for Integrative Genomics, Princeton UniversityGrace McKenzie-Smith, Department of Physics and Lewis-Sigler Institute for Integrative Genomics, Princeton UniversitySophie Leheny, Department of Molecular Biology, Princeton UniversityJoshua Shaevitz, Department of Physics and Lewis-Sigler Institute for Integrative Genomics, Princeton UniversitySarah Kocher, Department of Ecology and Evolutionary Biology and Lewis-Sigler Institute for Integrative Genomics, Princeton UniversityNAPS was created in theKocherandShaevitzlabs at Princeton University.LicenseNAPS is licensed under the MIT license. See theLICENSEfile for details.AcknowledgementsMuch of the structure and content of the README and the documentation is borrowed from theSLEAP repository.
Package: naptan
naptan: a python packageGet, view, and map NaPTAN data.The package's functions return the data from the NaPTAN API as a pandas.DataFrame. This allows the data to be easily filtered, queried and manipulated. Once you have the data, you can export the data as a geoJSON, or view it via an interactive map."""Example code to view all the NaPTAN stops within Leicester andLeicestershire on a map in the browser."""importnaptan# get data as a dataframe# 260 is Leicestershire and 269 is Leicesterleics_stops=naptan.get_area_stops(['260','269'])# View the stops in the browser on an interactive map.naptan.view_map(leics_stops)InstallationThe latest release can be installed with:$pipinstallnaptanDocumentationAll documentation, tutorials, API reference etc can be found at the package's site:https://mullinscr.github.io/naptan/LicenseMIT. See LICENSE.txt.NaPTAN datasetNational public transport access nodes (NaPTAN) is a national dataset of all
public transport 'stops' in England, Scotland and Wales. Bus stops form the vast
majority of the dataset; but there is data on tram, metro, tube, rail, ferry and
air services too.Included in the dataset, along with the unique identifiers, is common name,
locality, stop type, bearing of onward travel, and status (active, inactive or pending).More information can be found on the UK government's website:NaPTAN guide for data managersNPTG and NaPTAN schema guide (2.5) (pdf)
Package: nap-token-auth
Simple Token-based authentication.OverviewA lot of people talk about having Token Auth for their REST APIs… but what does it actually mean?  And what benefit is it?The token is cryptographically signed chunk of data.  In this case it contains the user ID, backend, and a timestamp of when it was issued.This lets you generate and issue tokens to phone apps, services, etc, and not have to deal with logins, passwords, CSRF, etc.InstallAdd to settings.MIDDLEWARE, after the default authentication
middleware:MIDDLEWARE=['django.middleware.security.SecurityMiddleware','django.contrib.sessions.middleware.SessionMiddleware','django.middleware.common.CommonMiddleware','django.middleware.csrf.CsrfViewMiddleware','django.contrib.auth.middleware.AuthenticationMiddleware','nap_token.middleware.NapTokenMiddleware','django.contrib.messages.middleware.MessageMiddleware','django.middleware.clickjacking.XFrameOptionsMiddleware','cloudselect.middleware.CORSDefeat',]UsageWhen you want to log in a user, callnap_token.get_auth_token(user), passing
a User instance returned fromdjango.contrib.auth.authenticate.It will return a signed, timestamped token.  The client need only pass this in
aAuthorizationheader, formatted as ‘Bearer {token}’, for the request to
act as that user.  If the token is absent, expired, or invalid,requset.userwill fall back to the normal Session Based Auth.Issuing TokensAs a quick and dirty example of how to issue tokens, here’s an approach that
will issue a token for a user who can log in:fromdjango.httpimportHttpResponsefromdjango.contrib.auth.viewsimportLoginViewfromnap_tokenimportget_auth_tokenclassTokenView(LoginView):defform_valid(self,form):user=form.get_user()returnHttpResponse(get_auth_token(user))
Package: na-quantors
OverviewThe na_quantors project is a small collection of functions that check arguments for being na-values.InstallationTo install na_quantors, you can usepip. Open your terminal and run:pipinstallna_quantorsLicenseThis project is licensed under the MIT License.CreditsAuthor: JohannesEmail:johannes-programming@posteo.orgThank you for using na_quantors!
Package: narator
Usagevirtualenv --python=python3 sandbox. sandbox/bin/activatepip install -r requirements.txtGITHUB_TOKEN=python narator/narator.py <url-to-work-report-issue>ExampleIssue description:Title 1

todo create PR
done investigate
done discuss with team#1Output:#### Title 1-DONE:-investigate-discuss with team#1-TODO-create PR