Saravanan666/pypi-org huggingface dataset:
Package: nara-wpe
Weighted Prediction Error for speech dereverberationBackground noise and signal reverberation due to reflections in an enclosure are the two main impairments in acoustic
signal processing and far-field speech recognition. This work addresses signal dereverberation techniques based on WPE for speech recognition and other far-field applications.
WPE is a compelling algorithm to blindly dereverberate acoustic signals based on long-term linear prediction.The main algorithm is based on the following paper:
Yoshioka, Takuya, and Tomohiro Nakatani. “Generalization of multi-channel linear prediction methods for blind MIMO impulse response shortening.” IEEE Transactions on Audio, Speech, and Language Processing 20.10 (2012): 2707-2720.ContentIterative offline WPE/ block-online WPE/ recursive frame-online WPEAll algorithms implemented both in Numpy and in TensorFlow (works with version1.12.0).Continuously tested with Python 3.6, 3.7, 3.8 and 3.9.Automatically built documentation:nara-wpe.readthedocs.ioModular design to facilitate changes for further researchInstallationInstall it directly with Pip, if you just want to use it:pipinstallnara_wpeIf you want to make changes or want the most recent version: Clone the repository and install it as follows:gitclonehttps://github.com/fgnt/nara_wpe.gitcdnara_wpepipinstall--editable.Check theexample notebookfor further details.
If you download the example notebook, you can listen to the input audio examples and to the dereverberated output too.CitationTo cite this implementation, you can cite the following paper:@InProceedings{Drude2018NaraWPE,
  Title     = {{NARA-WPE}: A Python package for weighted prediction error dereverberation in {Numpy} and {Tensorflow} for online and offline processing},
  Author    = {Drude, Lukas and Heymann, Jahn and Boeddeker, Christoph and Haeb-Umbach, Reinhold},
  Booktitle = {13. ITG Fachtagung Sprachkommunikation (ITG 2018)},
  Year      = {2018},
  Month     = {Oct},
}To view the paper seeIEEE Xplore(PDF)
or for a preview seePaderborn University RIS(PDF).Comparision with the NTT WPE implementationThe fairly recent John Hopkins University paper (Manohar, Vimal:Acoustic Modeling for Overlapping Speech Recognition: JHU CHiME-5 Challenge System, ICASSP 2019) reporting on their CHiME 5 challenge results dedicate an entire table to the comparison of the Nara-WPE implementation and the NTT WPE implementation.
Their result is, that the Nara-WPE implementation is as least as good as the NTT WPE implementation in all their reported conditions.Development historySince 2017-09-05 a TensorFlow implementation has been added tonara_wpe. It has been tested with a few test cases against the Numpy implementation.The first version of the Numpy implementation was written in June 2017 while Lukas Drude and Kateřina Žmolíková resided in Nara, Japan. The aim was to have a publicly available implementation of Takuya Yoshioka’s 2012 paper.
Package: narchi
narchi - A neural network architecture definition packagenarchiis as python package that provides functionalities for defining neural
network architectures in an implementation independent way. It is intended
to make network architectures highly configurable while also making the task
easier.Main featuresNetwork architectures are written injsonnet format, which provides useful features like input
parameters and functions to define repeated blocks.The shapes of the tensors internal to the networks are automatically deduced
by propagating the shapes of the inputs, thus requiring less effort and being
less error prone.Propagation of shapes is done using symbolic arithmetic which makes it
simple to understand relationships between inputs and the derived shapes.Architecture files can reference other architecture files, thus making this
approach modular.A command line tool is included to validate jsonnet architecture files and to
create detailed diagrams of the respective network architectures.Severalexamplesintended to illustrate different features supported.Includes basic implementations that allows to instantiate pytorch modules:Instantiation only requires a jsonnet architecture file.No need to write module classes or forward function for each new architecture.One basic implementation that supports instatiating several of the examples.A second example that supports packed 1d and 2d sequences which illustrates the implementation independent nature of the architecture files.Teaser exampleHere you can see an example that illustrates whatnarchiprovides. The example
is for resnet18 as implemented in torchvision, though bare in mind that the
potential ofnarchiis the ease of configurability of network architectures, not
the reimplementation of existing architectures.Instantiating a pytorch module from the architecture file can be easily done as
follows.fromnarchi.instantiators.pytorchimportStandardModulemodule=StandardModule('resnet.jsonnet',state_dict='resnet18-5c106cde.pth',cfg={'ext_vars':{"num_blocks":[2,2,2,2]}})Creating a diagram of the architecture requires a single command like the following.narchi_cli.pyrender\--ext_vars'{"num_blocks": [2, 2, 2, 2]}'\--nested_depth4\resnet.jsonnet\resnet18.pdfBelow you can see a small part of the rendered diagram of the start of the
first downsample layer of resnet18.The part of the json that generated the previous crop of the architecture
diagram can be seen below. Note that information of the shapes is not included,
since these are derived automatically.{"_class":"Sequential","_id":"layer2","blocks":[{"_class":"Group","_name":"ResBlock","blocks":[{"_class":"Identity","_id":"ident"},{"_class":"Conv2d","_id":"conv1","bias":false,"dilation":1,"kernel_size":3,"output_size":128,"padding":1,"stride":2},{"_class":"BatchNorm2d","_id":"bn1"},{"_class":"Sequential","_id":"downsample","blocks":[{"_class":"Conv2d","bias":false,"kernel_size":1,"output_size":128,"padding":0,"stride":2},{"_class":"BatchNorm2d"}]},{"...":"..."}],"graph":["ident -> conv1 -> bn1 -> relu1 -> conv2 -> bn2 -> add -> relu2","ident -> downsample -> add"],"input":"ident","output":"relu2"}]}
Package: narcissus.app
This package contains the “wsgi” components fornarcissus.Narcissus is a web application that visualizes web server hits
as they happen in real time.Features:IP addresses converted to latitude/longitude, then streamed via
WebSockets topolymaps.Realtime graphs of what countries are downloading what content withd3.Ømq (zeromq)on the backend.Fast.  No polling.Live DemoYou can seenarcissusrunning live atnarcissus.rc.rit.edu.The Research Computing department at the Rochester Institute of Technology runs
thatnarcissusinstance.  It is pointed at theirveryactiveFOSS mirror.  (That site is the highest-traffic site at RIT!)SourceGet the source fromgithub.com.
Package: narcissus.common
This package contains the “common” components fornarcissus.Narcissus is a web application that visualizes web server hits
as they happen in real time.Features:IP addresses converted to latitude/longitude, then streamed via
WebSockets topolymaps.Realtime graphs of what countries are downloading what content withd3.Ømq (zeromq)on the backend.Fast.  No polling.Live DemoYou can seenarcissusrunning live atnarcissus.rc.rit.edu.The Research Computing department at the Rochester Institute of Technology runs
thatnarcissusinstance.  It is pointed at theirveryactiveFOSS mirror.  (That site is the highest-traffic site at RIT!)SourceGet the source fromgithub.com.
Package: narcissus.hub
This package contains the “hub” components fornarcissus.Narcissus is a web application that visualizes web server hits
as they happen in real time.Features:IP addresses converted to latitude/longitude, then streamed via
WebSockets topolymaps.Realtime graphs of what countries are downloading what content withd3.Ømq (zeromq)on the backend.Fast.  No polling.Live DemoYou can seenarcissusrunning live atnarcissus.rc.rit.edu.The Research Computing department at the Rochester Institute of Technology runs
thatnarcissusinstance.  It is pointed at theirveryactiveFOSS mirror.  (That site is the highest-traffic site at RIT!)SourceGet the source fromgithub.com.
Package: narcolepsy
Puts code to sleep.OverviewThenarcolepsypackage contains code which alters the behavior of your
application/api by injecting random sleep calls into decorated functions.UsageThe following code is an example of using the@narcolepticdecorator.from narcolepsy import narcoleptic

@narcoleptic(max=5)  # sleep for 5 seconds at max
def foobar():
    for x in xrange(1024):
        nested_function(x)The@narcolepticdecorator takes three parameters (all optional):min: The minimum sleep time in seconds.max: The maximum sleep time in seconds.chance: The maximum number of lines that will be executed before asleep()call is injected.If nominormaxare passed in, the constants defined innarcolepsy.constantswill be used instead.
If nochanceis passed in, a value will be derived from the number of lines
in the input function.InstallationThe easiest way to installnarcolepsyis viapip:$ pip install narcolepsyKnown IssuesAs mentioned in theofficial documentation,sys.settrace()isn’t part
of the Python language definition and thus, may not be available to all
Python implementations.Why?In theory this could help test time-critical code (multi-producer/consumer
concurrent applications), but I mostly just wanted to play around with line
tracers.DisclaimerThis is a proof of concept and probably shouldn’t be used in any sort of
real-world scenario where testing of time-critical code has any measure of
importance.USE AT YOUR OWN RISK!LICENSESee the LICENSE file for details.
Package: narc-testrun-finished
Normally when testruns in slick (http://code.google.com/p/slickqa) are finished, the program
that uploaded the results marks the testrun as finished.  This is not possible in some
scenarios, including when doing distributed testing.This plugin watches testrun updates, and whenever a testrun that had NO_RESULT results no
longer has NO_RESULT results, it marks the testrun as finished.  This will trigger the
emails in narc.
Package: nard-backgammon
Nard Game (Backgammon)Classic board game of Nard (Backgammon) for two players.Common rulesPlayers: the game is played by two playersTables board of 24 points or spaces; 2 dice; 30 pieces (15 per player)Both players throw a die to decide who plays first; the one with the higher die leads offBearing off:Begins once all 15 pieces are in the home quadrantOne piece is removed from the point corresponding to the roll of each dieIf there are no piece on the point corresponding to a die roll, the player must make a legal move with a piece further awayIf that is not possible, a piece is borne off from the furthest point that is occupied.UsagePlayingfromnard_backgammonimport(Nard,NardState,Player,get_random_move,board_to_str)# If the first_player is None, then the starting# player is found on the first roll `first_roll()`game=Nard.new(first_roll_player=Player.WHITE)whileTrue:matchgame.state:# If first_roll_player is None then# NardState is will be FIRST_ROLL at the initcaseNardState.FIRST_ROLL:game.first_roll()caseNardState.PLAYING:# get valid moves for active playermoves=game.get_valid_moves()ifnotmoves:game.skip()continuemove=get_random_move(moves)game.play_move(move)print(board_to_str(game))caseNardState.ENDED:print(f'Winner:{game.outcome.winner}')break# End game, exit the loopOutput...
            ||12-11-10-9--8--7-||6--5--4--3--2--1-||
            ||o  o  x  x     x ||                 ||
            ||2     2  7     2 ||                 ||
            ||                 ||                 || White off: 0
            ||                 ||                 || Black off: 4
            ||                 ||                 || Dices: (4, 3)
            ||               2 ||      4  3       ||
            ||            o  o ||   o  o  o  o    ||
            ||13-14-15-16-17-18||19-20-21-22-23-24||
...
Winner: Player.WHITE
Package: nardis
NardisA web framework based on ASGI. This is inspired by the Express framework for node.js.Current statusStill not production-ready.This API is currently experimental, and is subject to change at any time.As such, please don't use this for production applications yet.However, please do play around with it. Any feedback at this stage is welcome as the API becomes more stable.RequirementsPython 3.6+InstallationVia pipRun the following:$ pip install nardisFrom sourceTo build from source, clone this repo, and then:$ python setup.py installExampleHere's a quick example you can use. Create anapplication.pyand copy and paste this:fromnardis.asgiimportmainfromnardis.routingimportGetasget,Postaspostimportasynciotemplate_start="""<!doctype html><head><title>example</title></head><body>"""template_end="""</body>"""asyncdefindex(req,res):"""This just demonstrates that you can write async code. Don't actually write this in production."""awaitres.send(template_start,more=True)forxinrange(10,0,-1):awaitres.send(f"<p>{x}!</p>",more=True)awaitasyncio.sleep(1)awaitres.send("<p>liftoff!</p>",more=True)awaitres.send(template_end)asyncdefhello(req,res):"""Try going to http://127.0.0.1:8000/hello/your_name/You'll see "Hello, your_name!""""name=req.params.get('name','world')awaitres.send(f"<h1>Hello,{name}!</h1>")routes=[get(r"^/?$",index),get(r"^/hello/(?P<name>\w+)/?$",hello),]config={'routes':routes,}app=main(config)# this is the ASGI applicationif__name__=='__main__':fromuvicorn.runimportrunrun(app,'127.0.0.1',8000)And then:$ python application.pyAlternatively, you could also do the following:$ uvicorn application:appThis should start a server onhttp://127.0.0.1:8000Using other web serversCurrently, Uvicorn is a dependency of Nardis.The codebase doesn't actually use Uvicorn, but this dependency allows you to run your application quickly (see above example). This dependency might be removed in the future.Nardis should also work with other ASGI-based web servers, like Daphne.To get Daphne working with the example code above, you could do the following:$ daphne application:app
Package: naref
NAREFNeutral Atom Renewable Energy ForecastingThis file showcases quantum and classical reservoirs in a simple example.importnareffromnaref.classical.hyperimportHyperCfromnaref.quantum.hyperimportHyperQfromnaref.quantumimportQRCfromnaref.classicalimportCRCfromnarefimportdataqrc=QRC(sample_len=8,nb_atoms=9,N_samples=1024,inp_duration=1000,reset_rate=0,geometry="grid_lattice_centred",atom_distance=15,input_type="mackey",test_len=data.real_test_len,train_len=data.real_train_len,verbose=True)qrc.build_model(data.mackey[:250],data.mackey[250:280])qrc.show_test_prediction()qrc.show_train_prediction()qrc.get_error_train()qrc.get_error_test()Building Quantum Reservoir...
10 training steps finished, training time : 24.890s
20 training steps finished, training time : 24.411s
30 training steps finished, training time : 24.441s
40 training steps finished, training time : 25.471s
50 training steps finished, training time : 25.757s
60 training steps finished, training time : 25.194s
70 training steps finished, training time : 24.324s
80 training steps finished, training time : 24.378s
90 training steps finished, training time : 31.824s
100 training steps finished, training time : 29.980s
110 training steps finished, training time : 28.739s
120 training steps finished, training time : 27.935s
130 training steps finished, training time : 30.140s
140 training steps finished, training time : 31.482s
150 training steps finished, training time : 33.550s
160 training steps finished, training time : 33.109s
170 training steps finished, training time : 31.198s
180 training steps finished, training time : 32.346s
190 training steps finished, training time : 34.320s
200 training steps finished, training time : 37.271s
210 training steps finished, training time : 37.513s
220 training steps finished, training time : 33.800s
230 training steps finished, training time : 35.306s
240 training steps finished, training time : 34.594s
Training finished. Total training time: 731.384s
Train error (Mean absolute error regression loss):  5.165748453421183e-15
10 testing steps finished, testing time : 36.515s
20 testing steps finished, testing time : 34.390s
Test error (Mean absolute error regression loss):  0.0149275627603316660.014927562760331666crc=CRC(sample_len=8,nb_neurons=9)crc.build_model(data.mackey[:250],data.mackey[250:280])crc.show_test_prediction()crc.show_train_prediction()crc.get_error_test()Building Classical Reservoir...0.047504000683266046crc.get_error_train()0.05308248069948858crc=CRC(sample_len=8,nb_neurons=15)crc.build_model(data.mackey[:500],data.mackey[500:530])crc.show_test_prediction()crc.show_train_prediction()crc.get_error_test()Building Classical Reservoir...0.009784391178625047crc.get_error_train()0.008250889994704327
Package: naren-api
::: Base Skeleton for Data-Science Projects :::Steps to run this Bare-Bones Template:{Note}: Operates exclusively within the 'Git Bash' environment.Run below commandpythontemplate.py-|- Upon initiating the project, remove the 'temp.log' temporary log file.-|- Include modules or packages in the requirements.txt file according to the specific requirements of your project.-|- Modify the 'setup.cfg' and 'setup.py' files according to the specific requirements(project_name_description) of the project.Run below commandbashinit_setup.shTo activate environment in bash:source~/Anaconda3/etc/profile.d/conda.sh
condaactivatevenv/Run below command (optional)pytest-v
toxThe base skeleton for a data science project typically includes the following components:Project Structure:Create a well-organized directory structure for your project.Divide folders for data, code, documentation, and models.Data Collection and Exploration:Gather relevant data from various sources.Explore and understand the data through descriptive statistics and visualizations.Data Cleaning and Preprocessing:Handle missing values, outliers, and inconsistencies in the data.Transform and preprocess the data for analysis.Feature Engineering:Create new features or transform existing ones to improve model performance.Model Building:Select appropriate algorithms based on the problem.Split the data into training and testing sets.Train and evaluate models using appropriate metrics.Model Deployment:Deploy the chosen model for real-world use if applicable.Documentation:Provide clear documentation for your code, including comments and a README file.Version Control:Use version control (e.g., Git) to track changes and collaborate with others.Testing and Validation:Implement testing procedures to validate the correctness of your code.Visualization and Reporting:Create visualizations to communicate insights.Prepare a report summarizing the findings and methodology.This basic structure ensures a systematic and reproducible approach to data science projects.
Package: narizaka
NarizakaTool to make high quality text to speech (tts) corpus from audio + text books.How it worksFirst it splits audio files in to small segments 5-15 seconds, then it iterates over each segment
and transcribes with whisper ASR and alligns this transcription with original text, if distance is very small we consider it as match and add it to the dataset.Installationpip install narizakaOr if you plan to modify sources:git clone https://github.com/patriotyk/narizaka.git
pip install -e narizaka/Flag-emeans that you can edit source files in the directory where you have cloned this project and they will be reflected when you run commandnarizakaHow to useApplication accepts two inputs. First one, it is audio data, that can be folder of audio files, or just one audio file.
And text, that can be any document that acceptspandocapplication.
Example:narizaka -a test_data/farshrutka -t test_data/Farshrutka.fb2This repository containstest_datathat includes audio and text books that you can use for testing.
Package: nark
nark is a Python 3 support library for (at least one) journaling,
time tracking, and personal relationship management application(s).nark provides an API for storing, retrieving, and reporting on time interval
data, aka timesheet or journal entries.NOTE:You probably want to install aclient application,
such asdob– nark is usually installed automatically.But if you want, you can install nark manually withpip:pip install narkFor other setup options, read theinstallation guide.Storynarkis inspired byHamster,
the esteemed time tracking application forGNOME.narkis Hamster-friendly.Upgrade your existing databaseand startdobbingtoday!narkis a fork of the latent modernhamster-libcode rewrite.
The nark developers appreciate such a wonderful starting point!narkis simply aFactstorage and reporting API, and does not
care about the database nor the user interface.
nark does one thing – and only one thing – and hopefully well!narkis developed with the goal that any Python developer – with
a few extra minutes and a sense of adventure – would feel comfortable
banging on it when it breaks, or adding new features where they see a
need for improvement. (But hopefully you’ll find that nark just works,
and that it already does what you want!)FeaturesDesigned for modern Python releases (3.6, 3.7, and 3.8).Naturally Unicode compatible – spice up your notes!Can migrate legacy Hamster databases (and fix integrity issues, too).Respectable coverage (to give you comfort knowing your Facts are safe).Decent documentation (including a live demo with inline instruction).Comfortable code base (focus on the feature, not on the format).Free and open source – hack away!See how you cancontributeto the project.ExampleThis is a simple nark library usage example using the Python interpreter,
showing how to create aFactinstance from aFactoidstring:$python3>>>fromnark.itemsimportFact>>>factoid='08:00 to 2019-02-16 10:00: act@cat: #tag1: Hello, nark!'>>>fact,err=Fact.create_from_factoid(factoid,time_hint='verify_both')>>>fact# Fact(
#   pk=None,
#   deleted=False,
#   split_from=None,
#   _start='08:00',
#   _end=datetime.datetime(2019, 2, 16, 10, 0),
#   _description='Hello, nark!',
#   activity=Activity(
#     pk=None
#     deleted=False,
#     _name='act',
#     category=Category(
#       pk=None,
#       deleted=False,
#       _name='cat',
#     ),
#   ),
#   tags=[Tag(
#     pk=None,
#     deleted=False,
#     _name='tag1',
#   )],
# )
Package: narmaw-profile
PyPi:https://pypi.org/project/narmaw_profile/Hello World!!! แพคเกจนี้ไว้สำหรับอธิบายการใช้ OOP และอัพโหลดไปยังเวป
pypi ได้วิธีติดตั้งเปิด CMD / Terminalpipinstallnarmaw_profileวิธีใช้งานแพ็คเพจนี้เปิด IDLE ขึ้นมาแล้วพิมพ์…my=Profile('Neko')my.company='narmaw-theseries'my.hobby=['Watch Series','Sleeping','Cooking']print(my.name)my.show_email()my.show_myart()my.show_hobby()print('------------------------')friend=Profile('Mumu')print(friend.name)friend.show_email()พัฒนาโดย: Mumu Nekoสอนโดย: ลุงวิศวกร สอนคำนวณ
Package: narmer
Narmer Experimental NLP/IR libraryCopyright 2015 by Christopher C. LittleThis library contains code I’m using for research, in particular dissertation research & experimentation.Suggested for testing & QA:Nose        (for unit testing)coverage.py (for code coverage checking)Pylint      (for code quality checking)PEP8        (for code quality checking)To install from PyPI:pip install narmerTo build/install/unittest in Python 2:sudo python setup.py install
nosetests -v --with-coverage --cover-erase --cover-html --cover-branches --cover-package=abydos .To build/install/unittest in Python 3:sudo python3 setup.py install
nosetests3 -v --with-coverage --cover-erase --cover-html --cover-branches --cover-package=abydos .For pylint testing, run:pylint --rcfile=pylint.rc abydos > pylint.logRelease History0.1.0 (2015-04-22)First Pre-Alpha commits to GitHub0.1.1 (2015-05-12)First Alpha release to PyPIAuthorsChristopher C. Little (@chrislit) <chrisclittle+narmer@gmail.com>
Package: naro
Naro PackageThis is a simple example package. You can useGithub-flavored Markdownto write your content.pypa tutorial 이것을 따라서 그대로 입력한 것이다.
setup.cfg 방식을 사용한다.
패키지의 이름: naro
테스트 시 네번째 번호을 계속 증가시키기로 한다.절차도구 업그레이드python3 -m pip install --upgrade build twine빌드rm ./dist/*
python3 -m build업로드python3 -m twine upload --repository testpypi dist/*배치python3 -m pip install --index-url https://test.pypi.org/simple/ --no-deps naro