Saravanan666/pypi-org huggingface dataset:
Package: naughtty
NaughTTYNaughTTYis a CLI tool and Python package for running commands in a pseudo-terminal.Full documentation is published atnaughtty.readthedocs.io.InstallationNaughTTYrequiresPython 3.8 or laterand acompatible operating system.pipinstallnaughttyNaughTTYrequires the host operating system to support forking and pseudo-terminals. GNU/Linux is good. At the time of writing, Windows is not.Basic CLI usagenaughttyAPP>output-with-escape-codes.txt
naughttyAPP|APP-THAT-USES-ESCAPE-CODESFor example:naughttypipenv--help>help.txt
naughttypipenv--help|lessFull documentation is published atnaughtty.readthedocs.io.Basic Python usagefromnaughttyimportNaughTTYntty=NaughTTY(["pipenv","--help"])ntty.execute()print(ntty.output)Usage: \033[39m\033[1mpipenv\033[39m\033[22m [OPTIONS] COMMAND [ARGS]...

\033[39m\033[1mOptions:\033[39m\033[22m
  --where                         Output project home information.
  --venv                          Output virtualenv information.
  --py                            Output Python interpreter information.
  --envs                          Output Environment Variable options.
  --rm                            Remove the virtualenv.
  --bare                          Minimal output.
  --completion                    Output completion (to be executed by the
                                \033[33m\033[1m  shell\033[39m\033[22m).
...Full documentation is published atnaughtty.readthedocs.io.👋 Hello!Hello!I'mCariad Ecclestonand I'm an independent/freelance software engineer. If my work has value to you, please considersponsoring.If you ever raise a bug, request a feature or ask a question then mention that you're a sponsor and I'll respond as a priority. Thank you!
Package: naughty-string-validator
A python library that returnsnaughty stringsfrom an offline database ofBig List of Naughty Stringsand emojis. The db will be continuously growing with each release.The Big List of Naughty Strings is an evolving list of strings which have a high probability of causing issues when used as user-input data.This library can be inluded in the test automation framework for API, UI, or DB testing to validate them against naughty strings.Installationpip install naughty_string_validatorUsagefromnaughty_string_validatorimport*To get a random naughty string from the listprint(get_random_naughty_string())#output"<a href=\"\\xE2\\x80\\x88javascript…(1)\"id=\"fuzzelement1\">test</a>"To get entire naughty string listprint(get_naughty_string_list())#output["","undefined","undef","null","NULL","(null)","nil",…]To get a random emoji from the emoji listprint(get_random_emoji())#output"😃"To get a entire emoji listprint(get_emoji_list())#output["😀","😃","😄","😁","😆","😅","😂","🤣","☺️","😊",…]TestsTo run testspy.test –cov=naughty_string_validator test/ –verboseDocumentationThe full documentation is at :https://naughty-string-validator-python.readthedocs.io/en/latest/index.html.History0.1.7 (2020-05-07)Minor improvements in codeFixed bug introduced by 0.1.6 of utils not found while importing in python version 30.1.2 (2018-09-03)Removed test code from build0.1.0 (2018-09-03)First release on PyPI.
Package: nauron
NauronNauron is a Flask wrapper for Python designed to enable simple creation of distributed services. It was designed
with AI applications in mind to keep GPU-accelerated or otherwise resource-intensive functionality separate from the
API logic.A Nauron-based API may have multiple services configured to it. Each service has one or more workers. The local
workers are simply instances of a Worker class. Remote workers are used when the communication with a Worker
class instance is done via a RabbitMQ message broker. When multiple identical instances are connected to the
message queue, the workload is automatically distributed between them.A detailed documentation of Nauron is coming soon.
Package: nauta-cli
nauta-cliOriginalateijelo/nauta-cliDescripciónnauta-clies una utilidad en línea de comandos (CLI) para la gestión del portal cautivoNautade Cuba.RequisitosInstale la última versión estable dePythonInstalaciónInstalación fácil con PIP:> python -m pip install --upgrade nauta-cliModo de usoCrear una entrada de usuario (card). En el terminal introducir:> nauta card add periquito@nauta.com.cuIntroducir la contraseña cuando se pida. Debe cambiarperiquito@nauta.com.cupor su usuario Nauta.Iniciar sesion:> nauta up periquitoSe muestra el tiempo en el terminal, para cerrar la sesión se debe pulsarCtrl+C.Opcionalmente puede especificar la duración máxima para la sesión, luego de la cual se desconecta automáticamente:> nauta up --time 60 periquitoEl ejemplo anterior mantiene abierta la sesión durante un minuto.Mas InformaciónLee la ayuda del modulo una vez instalado:> nautacli --help
Package: nautikos
NautikosA lightweight CI/CD tool for updating image tags in Kubernetes manifests.RationaleA GitOps CI/CD process often uses a deployment or ops repo containing Kubernetes manifests for multiple services and environments. Tools likeArgo-CDorFluxthen track these repo's, and apply any changes to the cluster. When a new image of an application is created, you want the corresponding tags to be updated in the manifests housed in the deployment repo. Doing this manually is error prone. Having to write logic in every repo or pipeline to perform this is tedious.This is where Nautikos comes in.InstallationpipinstallnautikosBasic usageNautikos is configured through a YAML-file (./nautikos.yaml), that specifies where the manifests for the different images and environments can be found:environments:-name:prodmanifests:-path:prod/app1/deployment.yaml# Path relative to configuration filetype:kubernetes# Type can be 'kubernetes' or 'kustomize'labels:# Optional specification of labels for more granular control-app1-refs/heads/main-path:prod/app2/kustomize.yamltype:kustomize-name:devmanifests:-path:dev/app1/deployment.yamltype:kuberneteslabels:-app1-refs/heads/dev-path:dev/app3/feature-A/deployment.yamltype:kuberneteslabels:-app1-refs/heads/feature-ANext, you can run Nautikos to update the image tags of specific images in different environments.nautikosmy-repo1.2.3# Updates all occurences of `my-repo` to `1.2.3` in all manifestsnautikos--envprodmy-repo2.3.4# Updates all occurences of `my-repo` to `2.3.4` in `prod/app1/deployment.yaml` and `prod/app2/deployment`nautikos--envdev--labelsapp1my-repo4.5.6# Updates all occurences of `my-repo` to `4.5.6` in `dev/app1/deployment.yaml`nautikos--labels'app1,refs/heads/main'my-repo5.6.7# Updates all occurences of `my-repo` to `5.6.7` in `prod/app1/deployment.yaml`Supported toolsThe tool works with standardKubernetesmanifests andKustomize-Helmmight be added later. Each have their own format for defining image tags.# Kubernetes manifestsspec:template:spec:containers:-image:some-repository:tag# Kustomizeimages:-name:some-repositorynewTag:tagAdvanced usageNautikos takes several options:--dry-run: prints the modified files to stdout, but doesn't edit in place--config config-file.yaml: path to config YAML, default is./nautikos.yamlAlternativesThere are basically three alternatives to do the same thing:Update manifests manually- of course this works, but this is not really proper CDWrite your own bash scripts in a pipeline using a tool likesedoryq- This works, but having to write this logic for every project is tedious.Use a tool likeArgo-CD Image updater- very nice, but a bit heavy-weight, not very actively developed, and doesn't seem to support Azure Container Registry.NotesMultiple YAML docs in one file is not yet supported.Dependenciestyper- for creating a CLIruamel.yaml- for handling YAML files while maintaining ordering and comments
Package: nautilus
# nautilus[![Join the chat athttps://gitter.im/nautilus/nautilus](https://badges.gitter.im/nautilus/nautilus.svg)](https://gitter.im/nautilus/nautilus?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
[![Build Status](https://travis-ci.org/nautilus/nautilus.svg?branch=master)](https://travis-ci.org/nautilus/nautilus)
[![Coverage Status](https://coveralls.io/repos/github/nautilus/nautilus/badge.svg?branch=master)](https://coveralls.io/github/nautilus/nautilus?branch=master)Nautilus is a framework for event-driven microservices that attempts to provide
extendible implementations of common aspects of a moden web application so that you can focus
on what you do best: building awesome, scalable services. Some of these features include:Distributed authenticationMessage passingCouple-free service joinsService API versioning (coming soon!)A flexible GraphQL API that adapts as services come onlineDistributed/remote database administration (coming soon!)Full documentation is hosted [here](http://nautilus.github.io/nautilus/).## Requirements
* >= Python 3.5
* Kafka
Package: nautiluscli
nautilusdb-cliA command-line tool forNautilusDB, a fully-managed,
cloud-native vector search service.NautilusDB is currently inpublic alpha. We're actively improving
the product and releasing new features and we'd love to hear your feedback!
Please take a moment to fill out thisfeedback formto help us understand your use-case better.By default, all collections are subject to permanent deletion after 2 weeks. Please let us know if you need to keep it for longer via the feedback form.QuickstartYou can try out NautilusDB right away. We have prepared a special public
collectionopenai-webthat can answer questions about the contents ofwww.openai.comnautiluscliaskopenai-web"what is red team?"InstallationInstall a released NautilusDB cli from pip.python3 version>= 3.10is requiredpip3installnautiluscliExamples:Create a new API keyYou can create a new API key and set it inNAUTILUSDB_API_KEYenvironment variable. NautilusDB will use this key to authorize access to
collections.nautilusclicreate-api-keyexportNAUTILUSDB_API_KEY='<key>'Check the current CLI configurationnautiluscliinfoCreate a new CollectionCreate a new collectionmyCollectionin the shared demo account.
A collection will be created that is only accessible to the configured API key.nautilusclicreate-collectionmyCollectionList CollectionsSee the list of Collection accessible to you, includingmyCollectionthat you just created.nautilusclilist-collectionsUpload file from URLIndex a PDF intomyCollection. In this example, we will index the original research paper on Transformers.nautiluscliupload-filemyCollectionhttps://arxiv.org/pdf/1706.03762.pdfUpload local fileAlternatively, upload a PDF from local file system for indexing.nautiluscliupload-filemyCollectionREADME.mdAsk questionsYou can now ask questions within the context of a collection and get answers.nautiluscliaskmyCollection"what is a transformer?"Delete the CollectionYou can optionally delete the collection. Deletions are non-reversible.nautilusclidelete-collectionmyCollection
Package: nautilus-ibapi
A couple of things/definitions/conventions:alow level messageis some data prefixed with its sizeahigh level messageis a list of fields separated by the NULL character; the fields are all strings; the message ID is the first field, the come others whose number and semantics depend on the message itselfarequestis a message from client to TWS/IBGW (IB Gateway)anansweris a message from TWS/IBGW to clientHow the code is organized:commmodule: has tools that know how to handle (eg: encode/decode) low and high level messagesConnection: glorified socketReader: thread that uses Connection to read packets, transform to low level messages and put in a QueueDecoder: knows how to take a low level message and decode into high level messageClient:knows to send requestshas the message loop which takes low level messages from Queue and uses Decoder to tranform into high level message with which it then calls the corresponding Wrapper methodWrapper: class that needs to be subclassed by the user so that it can get the incoming messagesThe info/data flow is:receiving:Connection.recv_msg()(which is essentially a socket) receives the packetsusesConnection._recv_all_msgs()which tries to combine smaller packets into bigger ones based on some trivial heuristicReader.run()usesConnection.recv_msg()to get a packet and then usescomm.read_msg()to try to make it a low level message. If that can't be done yet (size prefix says so) then it waits for more packetsif a full low level message is received then it is placed in the Queue (remember this is a standalone thread)the main thread runs theClient.run()loop which:gets a low level message from Queueusescomm.pyto translate into high level message (fields)usesDecoder.interpret()to act based on that messageDecoder.interpret()will translate the fields into function parameters of the correct type and call with the correct/corresponding method ofWrapperclasssending:Clientclass has methods that implement therequests. The user will call those request methods with the needed parameters andClientwill send them to the TWS/IBGW.Implementation notes:theDecoderhas two ways of handling a message (esentially decoding the fields)some message very neatly map to a function call; meaning that the number of fields and order are the same as the method parameters. For example: Wrapper.tickSize(). In this case a simple mapping is made between the incoming msg id and the Wrapper method:IN.TICK_SIZE: HandleInfo(wrap=Wrapper.tickSize),other messages are more complex, depend on version number heavily or need field massaging. In this case the incoming message id is mapped to a processing function that will do all that and call the Wrapper method at the end. For example:IN.TICK_PRICE: HandleInfo(proc=processTickPriceMsg),Instalation notes:you can use this to build a source distributionpython3 setup.py sdistyou can use this to build a wheelpython3 setup.py bdist_wheelyou can use this to install the wheelpython3 -m pip install --user --upgrade dist/ibapi-9.75.1-py3-none-any.whl
Package: nautilus-namecodes
Nautilus Filename Specification💠 View Project Documentation 📖💠 View Project on the Python Package Index 📦(nautilus-namecodes)Nautilus namecodes are encoded filenames for media and other artistic creations in filesystem based content management systems.InstallationTo instal this application you can use pip:package installer for Python.pip3 install nautilus-namecodesCommand Line Interface:While this application is primarily focused as an application library, a small command line interface is included.For example you can print all the Name Codes with this command:nautilus-namecodes codes --show-allLibraries UsedThis project depends on 'atoml' for processing the pyproject.toml file.MIT License Copyright (c) 2021 Frost Ming, 2018 Sébastien Eustacehttps://github.com/frostming/atomlThis project depends on 'typer' for creating the CLI.MIT License Copyright (c) 2019 Sebastián Ramírezhttps://github.com/tiangolo/typerThis project depends on 'pydantic' for Json Schema.MIT License Copyright (c) 2021 Samuel Colvinhttps://github.com/samuelcolvin/pydanticThis project includes 'SnakeMD' for generating Markdown.MIT License Copyright (c) 2021 Jeremy Grifskihttps://github.com/TheRenegadeCoder/SnakeMDNotesThis repository uses "pytest" to run python tests code.https://docs.pytest.org/en/latest/This repository uses "Black" to format python code.https://black.readthedocs.io/en/latest/This repository uses "mypy" to type check the python code.https://github.com/python/mypyThis repository uses 'pylint' to check the python code quality.https://pylint.org/This repository uses 'bandit' to code for security issues.https://bandit.readthedocs.io/en/latest/This repository uses 'isort' to check that imports are sorted.https://pycqa.github.io/isort/This repository uses Sphinx and Myst-Parser for documentation infrastructure.https://www.sphinx-doc.org/en/master/https://github.com/executablebooks/MyST-ParserDevelopment InstructionsThis repository uses [Poetry: Dependency Management for Python, include the 'Poetry Dynamic Versioning' extension].Install Python.https://www.python.org/downloads/sInstall Poetry and Poetry Dynamic Versioningpip3 install poetry poetry-dynamic-versioningClone thenautilus-namecodesrepository development tree.https://github.com/da2ce7/nautilus-namecodes/tree/developChange Directory to the cloned repository:cd nautilus-filename_specificationInstall Dependencies:poetry installRun Tests:poetry run toxCreate Distribution Package:poetry build
Package: nautilus-open-any-terminal
nautilus-open-any-terminalis an extension for nautilus, which adds an context-entry for opening other terminal emulators thangnome-terminal.Supported Terminal EmulatorsRight now the plugin is limited to these terminal emulators. If one is missing please open an issue.alacrittyblackboxcool-retro-termdeepin-terminalfoot/footclientgnome-terminalguakehyperkermitkgx(GNOME Console)kittykonsolemate-terminalmltermptyxisqterminalriosakurasttabbyterminatorterminologyterminustermitetilixurxvturxvtcwarpweztermxfce4-terminalxterm/uxtermInstallingFrom the AUR (Arch Linux)yay-Snautilus-open-any-terminalNixpkgs (NixOS)nix-env-iAnixos.nautilus-open-any-terminalFrom PYPIDependencies to install before:nautilus-python(python-nautilus/python3-nautilus(newer) package on Debian / Ubuntu)gir1.2-gtk-4.0(Debian / Ubuntu)User install:pipinstall--usernautilus-open-any-terminalSystem-wide install:pipinstallnautilus-open-any-terminalFrom sourcegitclonehttps://github.com/Stunkymonkey/nautilus-open-any-terminal.gitcdnautilus-open-any-terminal
make

makeinstallschema# User installsudomakeinstallschema# System installrestart nautilusThen kill Nautilus to allow it to load the new extension:nautilus-qSettingsTo configure the plugin’s behaviour make sure to run (system-wide):glib-compile-schemas/usr/share/glib-2.0/schemasor for (user-wide) installation:glib-compile-schemas~/.local/share/glib-2.0/schemas/via dconf-editorvia command-linegsettingssetcom.github.stunkymonkey.nautilus-open-any-terminalterminalalacritty
gsettingssetcom.github.stunkymonkey.nautilus-open-any-terminalkeybindings'<Ctrl><Alt>t'gsettingssetcom.github.stunkymonkey.nautilus-open-any-terminalnew-tabtruegsettingssetcom.github.stunkymonkey.nautilus-open-any-terminalflatpaksystemUninstallSincesetup.pydoes not provide a natively uninstall method the makefile has an uninstall option.makeuninstallscheme# user uninstallsudomakeuninstallscheme# system uninstall
Package: nautilus-registry
# nautilus-registryA module to support an "impure" nautilus architecture, taking advantage of a service registry## Installing`nautilus_registry` can be installed from pip:```bashpip install nautilus_registry```## Connecting a service to consulCurrently, `nautilus_registry` only supports consul and does so through aservice mixin:```pythonimport nautilusfrom nautilus_registry import RegisterMixinclass MyService(RegisterMixin, nautilus.Service):# ...```This mixin registers the service with consul when the service starts andhandles the removal of the service from consul aswell.## Referring to the registry in an APISchemas that are executed from services with this mixin can access various utility functions through the context:```pythonclass MyObjectType(graphene.ObjectType):field = Field(...)@graphene.with_content@graphene.resolve_only_argsdef resolve_field(self, context=None):# query the api for some datadata = context.service.query_api(...)```
Package: nautilus-sampler
Nautilus is an MIT-licensed pure-Python package for Bayesian posterior and evidence estimation. It utilizes importance sampling and efficient space exploration using neural networks. Compared to traditional MCMC and Nested Sampling codes, it often needs fewer likelihood calls and produces much larger posterior samples. Additionally, nautilus is highly accurate and produces Bayesian evidence estimates with percent precision. It is widely used in many areas of astrophysical research.ExampleThis example, sampling a 3-dimensional Gaussian, illustrates how to use nautilus.importcornerimportnumpyasnpfromnautilusimportPrior,Samplerfromscipy.statsimportmultivariate_normalprior=Prior()forkeyin'abc':prior.add_parameter(key)deflikelihood(param_dict):x=[param_dict[key]forkeyin'abc']returnmultivariate_normal.logpdf(x,mean=[0.4,0.5,0.6],cov=0.01)sampler=Sampler(prior,likelihood)sampler.run(verbose=True)points,log_w,log_l=sampler.posterior()corner.corner(points,weights=np.exp(log_w),labels='abc')InstallationThe most recent stable version of nautilus is listed in the Python Package Index (PyPI) and can be installed viapip.pipinstallnautilus-samplerAdditionally, nautilus is also on conda-forge. To install viacondause the following command.condainstall-cconda-forgenautilus-samplerDocumentationYou can find the documentation atnautilus-sampler.readthedocs.io.AttributionA paper describing nautilus's underlying methods and performance has been published in theMonthly Notices of the Royal Astronomical Society. A draft of the paper is also available onarXiv. Please cite the paper if you find nautilus helpful in your research.@article{nautilus,
    author = {Lange, Johannes U},
    title = "{nautilus: boosting Bayesian importance nested sampling with deep learning}",
    journal = {Monthly Notices of the Royal Astronomical Society},
    volume = {525},
    number = {2},
    pages = {3181-3194},
    year = {2023},
    month = {08},
    doi = {10.1093/mnras/stad2441},
    url = {https://doi.org/10.1093/mnras/stad2441},
    eprint = {https://academic.oup.com/mnras/article-pdf/525/2/3181/51331635/stad2441.pdf},
}LicenseNautilus is licensed under the MIT License. The logo uses an image from the Illustris Collaboration.
Package: nautiluszim
Nautilusnautilusturns a collection of documents into a browsableZIM file.It downloads the video (webm or mp4 format – optionally recompress it in lower-quality, smaller size), the thumbnails, the subtitles and the authors' profile pictures ; then, it creates a static HTML files folder of it before creating a ZIM off of it.Preparing the archiveTo be used with nautilus, your archive should be a ZIP file.it doesn't need to be structured, but it can.it doesn't need to be compressed. It's usually recommended not to.it should contain acollection.jsonfile, but it can also be provided separately (see below).it should only contain to-be-included files. No filtering is done.Audio and video files should be in ogg format with an.ogg/.ogvextension to be supported on all platforms (mp3/mp4would work only on platforms with native support).cd content/path
zip -r -0 -T ../content_name.zip *JSON collection fileEither inside the archive ZIP as/collection.jsonor elsewhere,
specified via--collection mycollection.json, you must supply a JSON file describing your content.The user-interface only gives access to files referenced properly in the collection.At the moment, the JSON file needs to provide the following fields for each item in an array:[{"title":"...","description":"...","authors":"...","files":["relative/path/to/file"]}]About pageEither inside the archive ZIP as/about.htmlor elsewhere, specified via--about myabout.html,You may supply an about page in HTML format. It will be displayed in a modal popup and will be included.At its bottom yoursecondary-logoif provided.Use only content tags (no<html />nor<head />nor<script />etc)Use inline styling if required, but no styling is recommended.Include one logo inline if required.Requirementswgetandunzipto install JS dependencies. Seeget_js_deps.shif you want to do it manually.wgetis used to download archive files as well.handlebarsis used to compile JS templatesInstallationnautilusis a python program. if you are not using the docker image, you are advised to use it in a virtual-environment. Seerequirements.txtfor the list of python dependencies.dockerdocker run -v my_dir:/output ghcr.io/openzim/nautilus nautiluszim --helppippip install nautiluszim
nautiluszim --helpUsagenautiluszim --archive my-content.zipNotesOn macOS, the locale setting is buggy. You need to launch it with theLANGUAGEenvironment variable (as ISO-639-1) for the translations to work.LANGUAGE=fr nautiluszim --language fraDevelopmentSeeCONTRIBUTING.md