Saravanan666/pypi-org huggingface dataset:
Package: nustarpipeline
# NuSTAR-pipelineThis package wrpas the nustar pipelines for point sources in convenient format for
an homogeneus analysis.Two executable scripts are provided in the package:
* process_nustar.py to perform the procesing
* get_nustar_data.py to download the data## TasksSeparate the ds9 region generation from spectral processingMake an Heasarc Docker container with Nustar CalDB.Use version as input variable.Tag the date of creation (for CALDB).Port the use of astroquery to find OBSIDs for a source in a given time interval.Adapt script to make image.Separate a function to create regions with interactive input from the user.Extract spectrum
Package: nusuGraph
nusuGraphAn asynchronous and simplified wrapper for the Telegraph API.Installationpipinstall-UnusugraphUsageimportasynciofromnusugraphimportTelegraphasyncdefmain():graph=Telegraph(token=None,# if no token was passed, then an anonymous account will be createdtokenList=None,# list of tokens to be used in a cycletimeout=10,# timeout for httpx.AsyncClient)# Create a Pagetext="Hello, world!"# Account will be created if no token was passedresponse=awaitgraph.createPage(author="Nusab Taha",htmlContent="<b>Hello</b>",title="Just Saying Hello")url=response["url"]print(url)# https://telegra.ph/Just-Saying-Hello-12-28-4# Upload Media from local fileimagePath="assets/sample.jpg"url=awaitgraph.uploadMediaFromFile(imagePath)print(url)# https://telegra.ph/file/daf9c776a1c25264321cd.jpg# Upload Media from it's bytes contentwithopen(imagePath,"rb")asfile:imageBytes=file.read()url=awaitgraph.uploadMediaFromBytes(content=imageBytes,fileType="image/jpeg")print(url)# https://telegra.ph/file/3406d7261c8c62869ab91.jpgif__name__=="__main__":asyncio.run(main())WHY?I needed a simple and asynchronous wrapper for the Telegraph API, with the ability to use multiple tokens in a cycle. That's the reason.
Package: nut2
This is an API overhaul ofPyNUT, a Python library to allow communication with NUT
(Network UPS Tools) servers.Note: This is an unofficial project, and is in no way supported or
endorsed by theNetwork UPS Tools developers.RequirementsThe module itself requires only Python (known to work with versions 2.6 through
3.4). If you wish to run the tests, dopip install-rrequirements-testing.txt.UsageExample:from nut2 import PyNUTClient
client = PyNUTClient()
client.help()
client.list_ups()
client.list_vars("My_UPS")Please note that this module has completely and intentionally broken
backwards compatibility with PyNUT 1.X.See inline documentation for more usage information.InstallationJust use pip:pip install nut2PyNUTThe following information is copied from the original PyNUT README:This directory contains various NUT Client related Python scripts, written by
David Goncalves, and released under GPL v3.“module”: this directory contains PyNUT.py, which is a Python abstraction
class to access NUT server(s). You can use it in Python programs to access NUT’s
upsd data server in a simple way, without having to know the NUT protocol.To import it on Python programs you have to use the following (case sensitive) :
‘import PyNUT’This module provides a ‘PyNUTClient’ class that can be used to connect and get
data from an upsd data server.To install the PyNUT module on Debian/Ubuntu, copy it to:
/usr/share/python-support/python-pynut/This directory also contains test_nutclient.py, which is a PyNUT test program.
For this to be fully functional, you will need to adapt the login, password and
upsname to fit your configuration.
Package: nutai
How to use this...You can substitutedockerforpodmanin these instructions.Buildpodmanbuild-tnut:latest.Runpodmanrun--namenut-redis-p6379:6379-dredis
podmanrun--namenut-p5000:5000-dnutUsecurl127.1:5000/documents/0
:"Not Found"curl-d'"z e r o"'-H'Content-Type: application/json'127.1:5000/documents/0
:200curl127.1:5000/documents/0
:'[{"id": "0", "score": 0}]'curl-d'"o r e z"'-H'Content-Type: application/json'127.1:5000/documents/0
:"Document already exists"curl-d'"o n e"'-H'Content-Type: application/json'127.1:5000/documents/1
:200curl127.1:5000/documents/1
:'[{"id": "0", "score": 0}, {"id": "1", "score": 0}]'
Package: nutanix-api
Nutanix APIWork in progressEasily interact with Nutanix API v3Installationpipinstallnutanix-apiUsagefromnutanix_apiimportNutanixApiClient,NutanixVM,NutanixClusterclient=NutanixApiClient("username","password",9440,"https://path/to/endpoint")# Virtual Machinevm=NutanixVM.get(client,"61b13e12-1494-11ed-861d-0242ac120002")vm.turn_off()# Turn VM offvm.turn_on()# Turn VM on# Clustercluster=NutanixCluster.get(client,"81b13e12-1494-11ed-861d-0242ac120003")print(cluster.name)
Package: nutcli
nutcli - cli in a nutshellThe Pythonnutclipackage allows you to easily create robust command-based
command line interface that can combine the best of the two worlds ofpythonandshell.It also provides several useful classes and decorators that can help you improve
the user experience by producing nicely formatted output and allowing dry runs
for operations with side effects.LinksProject source code:https://github.com/pbrezina/python-nutcliProject documentation:https://nutcli.readthedocs.ioProject at PyPi:https://pypi.org/project/nutcliInstallationpip3 install nutcliExample instead of thousands wordsBellow is the very basic example to get the idea of what this package does and
how its used.classHelloActor(Actor):defsetup_parser(self,parser):parser.add_argument('--hello',action='store',type=str)def__call__(self,hello):self.info(hello)return0classProgram:defmain(self,argv):# Create argument parser.parser=argparse.ArgumentParser()CommandParser('Example Commands')([Command('hello','Print hello message',HelloActor()),]).setup_parser(parser)# Create the runner object.runner=Runner('my-cli',parser).setup_parser()# Parse arguments - the runner internally process its own arguments# that were setup by previous call to `setup_parser()`.args=runner.parse_args(argv)# You can handle your own global arguments here.# Now we setup the default logger - it produces output to stdout# and stderr.runner.default_logger()# And finally, we execute the requested command and return its exit# code.returnrunner.execute(args)if__name__=="__main__":program=Program()sys.exit(program.main(sys.argv[1:]))$python3./main.pyhello--helloworld[my-cli] world$python3./main.py--helpusage: main.py [-h] [--log-execution] [--dry-run] [--no-colors] COMMANDS ...optional arguments:-h, --help       show this help message and exit--log-execution  Log execution of operations that supports it.--dry-run        Do not execute operations with side effects. Only log whatwould be done.--no-colors      Do not execute operations with side effects. Only log whatwould be done.Example Commands:COMMANDShello          Print hello message
Package: nut-cloud
nut_cloudan online shop and a cloud drive using SQLite, Flask as the backend and the Bootstrap framework to ameliorate the appearance of the frontend.UsageThe first timepip install nut-cloudFor Linux/macos/BSDs:$ export FLASK_APP="nut_cloud"For Windows Powershell:$ $env:FLASK_APP="nut_cloud"$ flask init-db(Only needed on the first time running nut_cloud)$ flask runLater$ python -c 'import nut_cloud; nut_cloud.create_app().run()'CAUTIONYou need to configure theSECRET_KEY,WEBHOOK_SECRET_KEYand theHOSTNAMEyourself!You can put aconfig.pyin the app instance folder to configure these settings.Auto deployYou can configure yourWEBHOOK_SECRET_KEYto match the secret key of Github Webhooks,
then you can use Systemd to monitor file changes under{instance path}/restart/and
restart theuwsgiserver each time any file is changed.LanguageSimplified ChineseLicenseCopyright (c) 2018-2019 Chijun Sima, Yixue ZhongLicensed under the MIT License.
Package: nutil
♆ NEPTUNENEPTUNEis a set of decoupledPython librariesintended to facilitate Python development:nfin,ngui,nlearn,nmath andnutil.The librarynutilcontains utility functions; among them:handlers of main types (including array, dataframe, date/time, dictionary, list and string) anddatabase interface (including the CRUD and upsert operations).NEPTUNE is based on popular libraries like numpy, pandas, plotly and scipy.InstallLaunch the following commands in a shell:gitclonehttps://github.com/b-io/io.barras.gitcdio.barras/python/neptune/
mvncleaninstallLicenseFeel free to download, try and share your suggestions about the libraries,
while respectingthis MIT License (MIT).
Package: nutils-poly
Low-level functions for evaluating and manipulating polynomials.ExamplesThe vector of coefficients for the polynomialf(x, y) = 3 x y + x^2is[0, 3, 0, 1, 0, 0].Witheval()we can evaluate this polynomial:importnutils_polyimportnumpycoeffs=numpy.array([0,3,0,1,0,0],dtype=float)# array of three `x` and `y` pairs (last axis)values=numpy.array([[1,0],[1,1],[2,3]],dtype=float)numpy.testing.assert_allclose(nutils_poly.eval(coeffs,values),[1,4,22])PartialDerivPlan::apply()computes the coefficients for the partial
derivative of a polynomial to one of the variables. The partial derivative
offtox, the first variable, is∂_x f(x, y) = 3 y + 2 x(coefficients:[3, 2, 0]):importnutils_polyimportnumpycoeffs=numpy.array([0,3,0,1,0,0],dtype=float)pd=nutils_poly.PartialDerivPlan(2,# number of variables2,# degree0,# variable to compute the partial derivative to)numpy.testing.assert_allclose(pd(coeffs),[3,2,0])Further readingThis package is a Python interface for the Rust cratenutils-polyusingPyO3.This package is part of theNutils project.
Package: nutjob
The NutJob client is an alternate Redis client based onredis.StrictRedis.  It is meant for use with Turnstile, in
conjunction with the Redis proxy nutcracker, aka twemproxy.  Certain
functionality which is unsupported by nutcracker is overridden in
NutJob, either to disable it (such as Turnstile’sPUBLISHto
report errors) or to replace it with equivalent functionality (such as
theregister_script()call used by the Turnstile compactor
daemon).NutJob is really only intended for use with Turnstile; it is not meant
as a general-purpose Redis/nutcracker client.How to UseTo use NutJob, add the following configuration settings to the
appropriate sections of your Turnstile configuration:[redis]
redis_client = nutjob
server_version = <see text>
host = <nutcracker IP>

[control]
redis_client = redis
server_version =
host = <Redis server IP>Note the overrides in the[control]section, particularly the
explicitly empty value ofserver_version: the Turnstile control
daemon MUST be configured to use the standard Redis client and to
connect to an actual Redis server; the control daemon relies on
functionality that nutcracker does not support.As for theserver_versionvalue in the[redis]section: this
value is optional, but if set, it should be the minimum server version
of the Redis servers connected behind the nutcracker proxy.  This
information is used by the Turnstile compactor daemon to enable an
optimization; normally, the compactor daemon determines whether to use
this optimization based on the server version reported by the Redis
server itself, but nutcracker does not support this version retrieval,
and so NutJob provides thisserver_versionside channel to allow
its use.
Package: nutpie
nutpie: A fast sampler for Bayesian posteriorsInstallationnutpie can be installed using Conda or Mamba from conda-forge withmambainstall-cconda-forgenutpieOr using pip:pipinstallnutpieTo install it from source, install a Rust compiler and maturin and thenmaturindevelop--releaseIf you want to use the nightly SIMD implementation for some of the math functions,
switch to Rust nightly and then install with thesimd_supportfeature in then
nutpie directory:rustupoverridesetnightly
maturindevelop--release--features=simd_supportUsage with PyMCFirst, PyMC and Numba need to be installed, for example usingmambainstall-cconda-forgepymcnumbaWe need to create a model:importpymcaspmimportnumpyasnpimportnutpieimportpandasaspdimportseabornassns# Load the radon datasetdata=pd.read_csv(pm.get_data("radon.csv"))data["log_radon"]=data["log_radon"].astype(np.float64)county_idx,counties=pd.factorize(data.county)coords={"county":counties,"obs_id":np.arange(len(county_idx))}# Create a simple hierarchical model for the radon datasetwithpm.Model(coords=coords,check_bounds=False)aspymc_model:intercept=pm.Normal("intercept",sigma=10)# County effectsraw=pm.ZeroSumNormal("county_raw",dims="county")sd=pm.HalfNormal("county_sd")county_effect=pm.Deterministic("county_effect",raw*sd,dims="county")# Global floor effectfloor_effect=pm.Normal("floor_effect",sigma=2)# County:floor interactionraw=pm.ZeroSumNormal("county_floor_raw",dims="county")sd=pm.HalfNormal("county_floor_sd")county_floor_effect=pm.Deterministic("county_floor_effect",raw*sd,dims="county")mu=(intercept+county_effect[county_idx]+floor_effect*data.floor.values+county_floor_effect[county_idx]*data.floor.values)sigma=pm.HalfNormal("sigma",sigma=1.5)pm.Normal("log_radon",mu=mu,sigma=sigma,observed=data.log_radon.values,dims="obs_id")We then compile this model and sample form the posterior:compiled_model=nutpie.compile_pymc_model(pymc_model)trace_pymc=nutpie.sample(compiled_model)trace_pymcnow contains an ArviZInferenceDataobject, including sampling
statistics and the posterior of the variables defined above.Usage with StanIn order to sample from Stan model,bridgestanneeds to be installed.
A pip package is available, but right now this can not be installed using Conda.pipinstallbridgestanWhen we install nutpie with pip, we can also specify that we want optional
dependencies for Stan models usingpip install 'nutpie[stan]'In addition, a C++ compiler needs to be available. For details seethe Stan docs.We can then compile a Stan model, and sample using nutpie:importnutpiecode="""data {real mu;}parameters {real x;}model {x ~ normal(mu, 1);}"""compiled=nutpie.compile_stan_model(code=code)# Provide datacompiled=compiled.with_data(mu=3.)trace=nutpie.sample(compiled)Advantagesnutpie usesnuts-rs, a library written in Rust, that implements NUTS as in
PyMC and Stan, but with a slightly different mass matrix tuning method as
those. It often produces a higher effective sample size per gradient
evaluation, and tends to converge faster and with fewer gradient evaluation.
Package: nutpy
nutpyAuthorJuan Bermejo Ballesteros (juan.bermejo@protonmail.com)Descriptionnutpy is a set of tools to study how space-telescopes with spin-precession scan strategies observe the sky. It has been developed by students from the Technical University from Madrid (Spain).InstallationPlease check theInstallation Guidein the projectwiki.DocumentationBasic documentation can be foundhereand some examples can also be found inbinder.ContributingIf you are interested in contributing to nutpy in someway, just contact me! You can find my email at the top and bottom of this readme.ProblemsIf you find any problem using mubody (quite probable to be fair), please
open an issue in theissue tracker.CitationIf you have used mubody, please cite us using:Bermejo-Ballesteros, Juan, et al. "Visibility study in a chief-deputy formation for CMB polarization missions." The Journal of the Astronautical Sciences 69.3 (2022): 651-691.Licensenutpy is released under the MIT license, hence allowing commercial use of the library. Please refer to theLICENSEfileContactFor any questions you can contact us using:juan.bermejo@protonmail.com
Package: nutratracker
NutritrackerExtensible command-line tool for nutrient analysis.Requires:Python 3.6.5 or laterRedis server(Optional)Android 5.0+ phone, USB, adb, developer modeInstall PyPi release (from pip)pip install nutri(Note:usepip3on Linux/macOS)Update to latestpip install -U nutriSubscribe to the preview/beta channelpip install nutri --preUnsubscribe (back to stable)pip uninstall nutri
pip install nutriUsing the source-code directlygit clone git@github.com:gamesguru/nutri.git
cd nutri
./nutri -hDownloading Food DataLinux/macOS Script (curl)cd ~
curl -L https://api.bitbucket.org/2.0/repositories/dasheenster/nutri-utils/downloads/nutri.zip -o nutri.zip
unzip -o nutri.zip
rm nutri.zipWindows (web download)Downloadnutri.zip:https://bitbucket.org/dasheenster/nutri-utils/downloads/Extract the.nutrifolder to your home folder.On Windows this isC:\Users\<your_name>On macOS it’s/Users/<your_name>On Linux it’s/home/<your_name>These can also be downloaded from the Android app, or synced over USB cable.You can also import your own flat file databases.  The full database import process is explained withnutri db --helpBetter directions for getting set up (on Windows) will (eventually) be postedon youtube.Currently Supported DataUSDA Stock databaseStandard flat file database, 8790 foodsRelative USDA ExtensionsFlavonoid, Isoflavonoids, and ProanthocyanidinsExtra FieldsIF,ORAC, GI, Omega-3, and (anti-nutrients) oxalic acid, mercury, etcNote:We are trying to start a collection of fields and make our models more general. Please upload and get in touch atgitter.im/nutritracker/nutri… (these can consist in magazine cutouts, NCBI tables, or other sources of nutrient data)Not Supported YetBranded Foods Database(LARGE 100MB+! PC ONLY)Canadian Nutrient FilesSimilar to USDAstock, except relational (not flat file)UsageMany features will require you to do the editing in notepad or your favorite text editor.  Then you can use theanalyzecommand to perform the analyses.Run thenutriscript to output usage.Usage:nutri <command>Commandsconfig                  change name, age, and vitamin targets

db                      import, edit and verify databases

field                   import, pair and manage fields

search                  search databases or recipes

analyze | anl           critique a date (range), meal, recipe, or food

sync                    sync android device

bugreport               upload database info, and version number

--help | -h             show help for a given command
Package: nutree
nutreeNutreeis a Python library for tree data structures with an intuitive,
yet powerful, API.Nutree FactsHandle multiple references of single objects ('clones')Search by name pattern, id, or object referenceUnobtrusive handling of arbitrary objectsCompare two trees and calculate patchesSave as DOT file and graphwiz diagramNodes can be plain strings or objectsDifferent traversal methods(De)Serialize to JSONFully type annotatedConvert to RDF graphTyped child nodesPretty printNavigationFilteringExampleA simple tree, with text nodesfromnutreeimportTree,Nodetree=Tree("Store")n=tree.add("Records")n.add("Let It Be")n.add("Get Yer Ya-Ya's Out!")n=tree.add("Books")n.add("The Little Prince")tree.print()Tree<'Store'>
├─── 'Records'
│    ├─── 'Let It Be'
│    ╰─── "Get Yer Ya-Ya's Out!"
╰─── 'Books'
     ╰─── 'The Little Prince'Tree nodes wrap the data and also expose methods for navigation, searching,
iteration, ...records_node=tree["Records"]assertisinstance(records_node,Node)assertrecords_node.name=="Records"print(records_node.first_child())Node<'Let It Be', data_id=510268653885439170>Nodes may be strings or arbitrary objects:alice=Person("Alice",age=23,guid="{123-456}")tree.add(alice)# Lookup nodes by object, data_id, name pattern, ...assertisinstance(tree[alice].data,Person)deltree[alice]Read the Docsfor more.
Package: nutri
PLEASE SEE THE NEW PAGEhttps://pypi.org/project/nutra/Thanks!Extensible command-line tool for nutraent analysis.Requires:Python 3.6.5 or laterPackage manager (pip3)Internet connectionSee database:https://github.com/gamesguru/ntdbSee server:https://github.com/gamesguru/nutra-serverInstall PyPi release (from pip)Please see the new pagenutra!
Package: nutrient
Bravo!  You have received a Medical Diploma in "nutrient" fromthe Orbital Convergence University International Air and Water Embassy of the Tangerine Planet.You are now officially certified to include "nutrient" in your practice.nutrientdescriptionThis is a module that can reliably
ascertain the health status of software.(It's like a testing framework)install[ZSH] pip install nutrientdocumentation (this opens a server process that sends HTML)[ZSH] nutrient sharesinternal status tests of the module[ZSH] nutrient internal-statusThese checks are run with pypi "body_scan""nutrient" is built from a fork of "body_scan"("body_scan" checks are written with "unittest")TutorialChecks are started simultaneously, unless "--simultaneous no"Create a status file (glob pattern "**/status_*.py").(The glob pattern can be modified with the progammatic python3 interface)# status_1.py

def check_1 ():
	print ("check 1")
	
def check_2 ():
	print ("check 2")
	
def check_3 ():
	raise Exception ("not 110%")

checks = {
	"check 1": check_1,
	"check 2": check_2,
	"check 3": check_3
}from a directory deeper than the status file "status_1.py"[ZSH] nutrient statusThis is the equivalent of:[ZSH] nutrient status --glob-string "**/status_*.py"The report then should appear like thispaths: [
	{
		"path": "../status_1.py",
		"empty": false,
		"parsed": true,
		"stats": {
			"passes": 2,
			"alarms": 1
		},
		"checks": [
			{
				"check": "check 1",
				"passed": true,
				"elapsed": [
					4.054199962411076e-05,
					"seconds"
				]
			},
			{
				"check": "check 2",
				"passed": true,
				"elapsed": [
					1.72930003827787e-05,
					"seconds"
				]
			},
			{
				"check": "check 3",
				"passed": false,
				"exception": "Exception('not 110%')",
				"exception trace": [
					"Traceback (most recent call last):",
					"  File \"/home/veganecology/.local/lib/python3.11/site-packages/nutrient/processes/scan/process/keg/check.py\", line 68, in start",
					"    checks [ check ] ()",
					"  File \"<string>\", line 13, in check_3",
					"Exception: not 110%"
				]
			}
		]
	}
]
alarms: [
	{
		"path": "../status_1.py",
		"checks": [
			{
				"check": "check 3",
				"passed": false,
				"exception": "Exception('not 110%')",
				"exception trace": [
					"Traceback (most recent call last):",
					"  File \"/home/veganecology/.local/lib/python3.11/site-packages/nutrient/processes/scan/process/keg/check.py\", line 68, in start",
					"    checks [ check ] ()",
					"  File \"<string>\", line 13, in check_3",
					"Exception: not 110%"
				]
			}
		]
	}
]
stats: {
	"alarms": 0,
	"empty": 0,
	"checks": {
		"passes": 2,
		"alarms": 1
	}
}Advanced TutorialIt's recommended to run nutrient programmatilly.An example of this can be found in the "_book/advanced tutorial"section of the documentation.Contactsbgrace2468@pm.me
Package: nutrinews
Use OpenAI’s GPT to make news more nutritious by removing bias. Based on
anidea from Alexandros
Marinos.Usageusage: nutrinews [-h] [-m {3.5,4}] [-p PROMPT] [--url URL] [-f FILE] [-c] [-d DIFF]

Remove bias from some text.

options:
  -h, --help            show this help message and exit
  -m {3.5,4}, --model {3.5,4}
                        GPT model to use.
  -p PROMPT, --prompt PROMPT
                        File containing instructions for removing bias.
  --url URL             Get text from this URL.
  -f FILE, --file FILE  Get text from this file.
  -c, --clipboard       Get text from the clipboard.
  -d DIFF, --diff DIFF  Specify tool to diff the original and nutritious text.InstallationpipinstallnutrinewsRequirementsPython 3 and associated libraries.LicenseMIT license.Authorsnutrinewswas written by`Dave Vandenbout <devb@xess.com><mailto:devb@xess.com>`__.
Package: nutripy
Table of ContentsNutripyInstallationUsageCompute daily needsWeight loss / mass gain management (work in progress)Nutripyfile:https://travis-ci.org/yafeunteun/nutripy.svg?branch=masterInstallationpip install nutripyUsageCompute daily needsimport nutripy
from nutripy import Nutripy

nut = Nutripy()
        
age = 25
weight = 60
height = 180
gender = nutripy.nutripy.Gender.MALE
activity = nutripy.nutripy.Activity.SEDENTARY
goal = nutripy.nutripy.Goal.GAIN
daily_needs = nut.get_daily_needs(age, weight, height, gender, activity, goal)Weight loss / mass gain management (work in progress)The main feature of Nutripy is its ability to manage one's weight
loss and/or weight gain.Work In Progress
Package: nutritionparser
Nutrition Parser is a package for parsing USDA National Nutrient Database
files.Changes0.1.2 (2015-08-28)Fixes bug with field names for the FOOD_DES.txt data file.Removes field in NUT_DATA.txt which is not included in the SR27
release.Fixes bug with CSV delimiter used in Python 2.7.0.1.1 (2015-08-28)Not publicly released.0.1.0 (2015-08-23)Initial public release