Saravanan666/pypi-org huggingface dataset:
Package: ncswash-fedex
Note: This was forked to publish something to PyPi that allowssetuptools>=58.Python FedEx SOAP API ModuleAuthor:Greg Taylor, Radek WojcikMaintainer:Python FedEx DevelopersLicense:BSDStatus:StableWhat is it?A light wrapper around FedEx’s Webservice Soap API. We don’t do much of any
validation, but we’ll help you sort through the pile of SOAP objects FedEx
uses.InstallationThe easiest way is via pip or easy_install:pip install fedexQuick StartClone this repository.Edit theexample_config.pyfile in Seeexamples/with your fedex credentials
and run any of the provided examples.DocumentationRefer to thedocumentationfor more details on the project. Latest doc builds
are found indocsand doc build scripts indoc_source. Sphinx documentation is indoc_src.There are also a lot of useful examples under the examples directory within
this directory.SupportIssues & Questions:https://github.com/gtaylor/python-fedex/issuesMost problems are going to require investigation or a submitted
pull request by someone from the Python FedEx Developers organization.
To contribute a new feature or service, feel free to create a pull request.
We are always looking for new contributors to help maintain the project.Fedex Support and DocumentationFedex Support Email:websupport@fedex.comDeveloper Portal:http://www.fedex.com/us/developer/Updates To Services:https://www.fedex.com/us/developer/web-services/process.html(FedEx Web Services Announcements)Related ProjectsFedEx Commercial Invoice Generation, seehttps://github.com/radzhome/fedex-commercial-invoiceTodosIncrease service specific request validationRemove deprecated services (package movement service)Pickup service unit testsLegalCopyright (C) 2008-2015 Greg TaylorCopyright (C) 2015-2016 Python FedEx DevelopersThis software is licensed under the BSD License.python-fedex is not authored by, endorsed by, or in any way affiliated with
FedEx.
Package: nc-time-axis
nc-time-axisSupport for a cftime axis in matplotlibInstallationInstallnc-time-axiseither withconda:condainstall-cconda-forgenc-time-axisOrpip:pipinstallnc-time-axisExampleimport random

import cftime
import matplotlib.pyplot as plt
import nc_time_axis

calendar = "360_day"
dt = [
    cftime.datetime(year=2017, month=2, day=day, calendar=calendar)
    for day in range(1, 31)
]
temperatures = [round(random.uniform(0, 12), 3) for _ in range(len(dt))]

plt.plot(dt, temperatures)
plt.margins(0.1)
plt.ylim(0, 12)
plt.xlabel("Date")
plt.ylabel("Temperature")
plt.show()Referencecftime- Time-handling functionality from netcdf4-python.matplotlib- Plotting with Python.
Package: nctoolkit
nctoolkitis a comprehensive Python (3.8 and above) package for analyzing netCDF data on Linux and macOS.Core abilities of nctoolkit include:Clipping to spatial regionsCalculating climatologiesSubsetting to specific time periodsCalculating spatial statisticsCreating new variables using arithmetic operationsCalculating anomaliesCalculating rolling and cumulative statisticsHorizontally and vertically remapping dataCalculating time averagesInteractive plotting of dataCalculating the correlations between variablesCalculating vertical statistics for the likes of oceanic dataCalculating ensemble statisticsCalculating phenological metricsOperation of the package requires the installation of Climate Data Operators (CDO). This is the computational backend for most of the methods used. No knowledge of CDO is required to use nctoolkit. A couple of methods provide users with the option of using netCDF Operators (NCO) as a backend. Guidance for how to install the backends are availablehere.The package is designed for both intensive bulk processing of NetCDF files and interactive Jupyter notebook analysis. It features an interactive plotting feature which allows users to view the contents of NetCDF files either within Jupyter notebooks or a web browser.Plotting requires the use of cartopy, which has some additional system dependencies. Follow the instructionshereto install them.Documentation and a user guide are availablehere.
Package: ncube-sdk
N-cube Python SDKInstallpipinstallncube-sdkUseimportosimportncube_sdk.client# initializeclient=ncube_sdk.client.init(service_url=os.environ["INGEST_URL"],schema_id=os.environ["INGEST_SCHEMA_ID"],service_auth=(os.environ["INGEST_AUTH_USER"],os.environ["INGEST_AUTH_PASS"]))# emit eventsclient.emit({"field1":"value1","field2":"value2"})
Package: ncutils
ncutils is a python module for niconico douga. You can install via pip/easy_install. Have fun!Documents and other resources are available atgithub.Releases0.3.0 (2012-10-08)Added ncsh, interactive shell for niconico dougaImproved tests0.2.1 (2012-09-10)Use setuptools to distribute scripts0.2.0 (2012-09-09)Support for WindowsAdded some scripts0.1.0 (2012-08-25)Initial Release
Package: ncvis
ncvisNCVisis an efficient solution for data visualization and dimensionality reduction. It usesHNSWto quickly construct the nearest neighbors graph and a parallel (batched) approach to build its embedding. Efficient random sampling is achieved viaPCGRandom. Detailed application examples can be foundhere.Usingimportncvisvis=ncvis.NCVis()Y=vis.fit_transform(X)More detailed examples can be foundhere.InstallationConda [recommended]You do not need to setup the environment if usingconda, all dependencies are installed automatically.$condainstallalartum::ncvisPip [not recommended]Important: be sure to have a compiler withOpenMPsupport.GCChas it by default, which is not the case withclang. You may need to installllvm-openmplibrary beforehand.Installnumpy,cythonandpybind11packages (compile-time dependencies):$pipinstallnumpycythonpybind11Installncvispackage:$pipinstallncvisFrom source [not recommended]Important: be sure to haveOpenMPavailable.First of all, download thepcg-cppandhnswliblibraries:$makelibsPython WrapperIfcondaenvironment is used, it replaces library search paths. To prevent compilation errors, you either need to use compilers provided bycondaor switch topipand system compilers.Conda$condainstall-cconda-forgecxx-compilerc-compilerconda-buildnumpycythonpybind11scipy
$conda-develop-bc.Pip$pipinstallnumpycythonpybind11
$makewrapperYou can then usepytestto run some basic checks$pytest-vrecipe/test.pyC++ BinaryRelease$makencvisDebug$makedebug
Package: ncvtk
Ncvtk has been designed with the aim of offering a high degree of interactivity to scientists
who have a need to explore three-dimensional, time-dependent planetary data.
The input data should be stored in a NetCDF file and the metadata should loosely follow the
CDC (http://www.cdc.noaa.gov/cdc/conventions/cdc_netcdf_standard.shtml) convention.
In particular, we support codes that are part of the Flexible Modeling System
(http://www.gfdl.noaa.gov/~fms/) infrastructure provided the data lie on a longitude/latitude,
structured grid.
Package: ncvx-sparse
ncvx-sparsencvx-sparseis a Python library for learning high-dimensional linear regresion models (single- and -multi-task) with nonconvex sparsity (e.g. SCAD, MCP, l1-group SCAD).
Solvers are written in Cython and implementation follows the Scikit-learn API.Why imposing sparsity with nonconvex penalties (e.g. LASSO) ? Because…Currently, thencvx-sparsesolves the following problems:Single-task linear regression,\arg \min_{\beta \in \mathbb{R}^p} \frac{1}{2n} \sum_i (y_i - x_i^{\top} \beta)^2 + \lambda \rho P(\beta) + \frac{1-\rho}{2} ||\beta||_2^2where P stands for:SCAD (SCADnet estimator), with parameter $gamma > 2$.Multi-task linear regression,\arg \min_{\beta = (\beta_1 \dots \beta_k) \in \mathbb{R}^{K \times p}} \frac{1}{2} \sum_j^K \sum_i^n (y_{ik} - x_{ik}^{\top} \beta_j)^2where P stands for:SCAD-l1 i.e. SCAD on the l1-norm of p-th feature vector accross the K tasks,SCAD-l2, same as SCAD-l1 but with respect to the l2-norm (not squared).Install the released versionCreate a Python=3.6 environment (e.g. Anaconda), and install ncvx-sparsefrom pip.  with the following command line in your Anaconda prompt:pip install -U ncvx-sparseExampleReferences
Package: nd2-dask
nd2-daskPlugin to load nd2 data into napariThisnapariplugin was generated withCookiecutterusing with@napari'scookiecutter-napari-plugintemplate.InstallationYou can installnd2-daskviapip:pip install nd2-daskContributingContributions 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,
"nd2-dask" is free and open source softwareIssuesIf you encounter any problems, pleasefile an issuealong with a detailed description.
Package: nd2-extractor
Setuppip install nd2-extractorFor notebook use:jupyter nbextension enable --py widgetsnbextensionUsageFrom a notebook:Then launchnd2_extractor_interactive.ipynbin a Jupyter notebook.From the command line$ nd2_extractor --help
usage: nd2_extractor.py [-h] --ND2_directory ND2_DIRECTORY --save_directory SAVE_DIRECTORY --save_type SAVE_TYPE [--workers WORKERS] [--t_stop T_STOP] [--fill_empty]

Extract and ND2 file to TIFF or PNG (zarr coming soon).

optional arguments:
  -h, --help            show this help message and exit
  --ND2_directory ND2_DIRECTORY
                        The absolute directory of the ND2 file.
  --save_directory SAVE_DIRECTORY
                        The absolute directory of the extraction folder.
  --save_type SAVE_TYPE
                        The file type to save as (PNG/TIFF/zarr).
  --workers WORKERS     The number of joblib workers to send to the extractor.
  --t_stop T_STOP       Extract up until this timepoint.
  --fill_empty          If supplied, will fill empty frames with empty images, or skip saving them. Will be ignored if zarr chosen.
Package: nda-api
nda_apiApi to fetch data from Nordea Investor websitePackage use chromedriver in order to render the Javascript from the page.Idea for the user:
Incorporate this package in a webapp with a REST api.
The data may then be fetched fully in Google slides.RequirementsInstallationPippip install nda_api  # Installing
pip install nda_api -U  # Upgrading already installed packageCondaconda install -c nda_apiUsageTheget_nda_fundamentalsmethod returns a pandas row.
Thus, it is easy to just append multiple stocks (tickers) to create a convenient dataframe.from aza_api.aza_api import get_aza_fundamentals
df = get_aza_fundamentals("CAST.ST")  # Castellum

print(df.T)

>>>

                               0
kortnamn                 CAST.ST
dividend_yield            0.0284
antal_aktier       84012900000.0
pe_ratio                    8.29
eps                         29.3
market_cap         84012900000.0
dividend/earnings            NaN
ncavps                       0.0
net_cash_ps                  0.0
price_book                     0
latest                     244.6DevelopmentWhile in root of this project.pip install -e .This will install the package in editable mode.Testingpytest tests/ -sPush project to Pip (PyPi) and CondaPyPihttps://medium.com/@joel.barmettler/how-to-upload-your-python-package-to-pypi-65edc5fe9c56Run in rootpython setup.py sdist
twine upload dist/*
Package: ndacrawler
NDA Website CrawlerThis crawler helps extract information from theNational Drug Authority(NDA) websitein Uganda.Installationpip install ndacrawlerExamplesGet list oflicensed drugsfromndacrawlerimportget_drugsdrugs=get_drugs()# Data Extractorsherbal_human_drugs=drugs["Herbal Human"]herbal_vet_drugs=drugs["Herbal Vet"]human_drugs=drugs["Human"]vet_drugs=drugs["Vet"]local_traditional_human_herbal_drugs=drugs["Local Traditional Human Herbal"]# Save to a csv fileherbal_human_drugs.to_csv("Herbal Human.csv")# Display the headers of the data# print(herbal_human_drugs.headers)# Display the data# print(herbal_human_drugs.data)
Package: ndar-backend
Back-end tools for NDAR.This package contains the following scripts:store_first_all_resultsstore_recon_all_resultsstore_structural_qaThe following environment variables must be defined for database uploads:DB_HOSTDB_SERVICEDB_USERDB_PASSWORDDependenciesThe upload scripts requirecx_Oracleto run.NDARNDAR is theNational Database For Autism Research.
Package: ndarray-listener
ndarray-listenerImplementation of theObserver patternfor NumPy arrays.Examplefromnumpyimportarrayfromndarray_listenerimportndla=ndl(array([-0.5,0.1,1.1]))classObserver(object):def__init__(self):self.called_me=Falsedef__call__(self,_):self.called_me=Trueo=Observer()a.talk_to(o)print(o.called_me)a[0]=1.2print(o.called_me)The output should beFalse
TrueInstallFrom command line, enterpipinstallndarray-listenerRunning the testsInstall dependenciespipinstallpytestthen runpython-c"import ndarray_listener; ndarray_listener.test()"DocumentationDocumentationAuthorsDanilo HortaLicenseThis project is licensed under theMIT License.
Package: ndar_unpack
ndar_unpack will download and unpack imaging data from NDAR.Examples:ndar_unpack -t thumbnail.png NDAR_INVOX992PCX_image03_1350375953058.zip

ndar_unpack --aws-access-key-id $access_key \
            --aws-secret-access-key $secret_key \
            -v volume.nii.gz \
            s3://NDAR_Central/NDAR_INVCH423DPL_image03_1357865972017.zipFor more information, runndar_unpack-h.Dependenciesndar_unpack needs the following to run:botopydicomTo actually do anything useful, ndar_unpack will also need:FreeSurferfor most operationsFSLfor thumbnail generationnifti_tool fromniftilibfor NIfTI header dumpingnibabelwith Minc2Image for MINC2 supportSimpleITKfor NRRD supportRunndar_unpack-Sto run a self-check and report what components are
found and what components are missing.NDARNDAR is theNational Database For Autism Research.  Access to NDAR data is governed by NDAR policies.
Package: ndautomata
Awesome cellular automata library created by Borja Esteban.Install it from PyPI$pipinstallndautomataUsageThis package is designed in order to create your own automata definitions based on 2 attributes:neighbours: List with relative indexes to cell neighbours.states: Number possible cell states.fromndautomataimportBaseAutomaton,neighboursclassAutomaton(BaseAutomaton):neighbours=neighbours.regular(ndim=1,r=1)states=2Note the automata dimensions are defined withneighbours.ndim.After you have defined your automaton, you can instantiate automata passing the initial configuration and the rule to the constructor function. Use the moduleinitializers, based onnumpyto generate the required arrays passing the number of states and size.fromndautomataimportinitializersrule=initializers.random(states=2,size=[2,2,2])ic=initializers.center(states=2,size=[200])ca=Automaton(ic,rule)Note the shape of the rule must always be[states] * neighbours.size.Plot the cellular automaton using matplotlib or your favorite tool.importmatplotlib.pyplotaspltplt.rcParams["image.cmap"]="binary"plt.matshow([next(ca)for_inrange(100)])plt.show()Seeexamplesfor more detailed use cases and examples on how to generate some plots.DevelopmentFork the repository, pick one of the issues at theissuesand create aPull request.
Package: ndb-audit
Adds an immutable audit trail to anyNDBentity
(includingExpando-based
models) built by theengineering team at Gain Compliance.Data structures are optimized for write performance and query-ability at
the expense of read performance and size of data. However, it is
minimally invasive on the entity you add it to. It only adds two
properties to the main entity totalling 32 characters and does not
prevent you from doing normal get by keyYou should read the below description of the data model (and especially
entity groups) to ensure you don’t cause datastore contention problems
with EGs that are too bigFeaturesFull history of an entity’s changes are recorded in a way that should
be easily query-ableAudit history is atomically updated when the entity is put, even if
all the entity’s properties are the sameSupports account (string), timestamp (datetime), data_hash (SHA-1 of
properties) trackingStrongly consistent retrieval of audit history(WIP)Flexible “tagging” system to track progress along the chain of
changes by a user, system, etc(Future) “at revision” fetching of data(Future) Diffing between revisions(Future) Collision detection and mergingData ModelFor a given entity ‘E’ of kind ‘EKind’, ndb_audit will monitor all puts
to entities who include the AuditMixin. Upon put a new Audit entity ‘A’
will be created which will be a complete copy of the entity. The entity
A will have the following:A will be of kind ‘Audit’A will carry the namespace if thenamespace_manageris usedA will contain a copy of every datastore property of E as it was when
it was putThe parent entity of A will be EThe key of A will be ndb.Key(parent=, pairs=[(‘Audit’, )])An attribute will be added to E called ‘d’, and a python property
will be added to your class to access this value as data_hash. This
value is added to your entity to allow caching based on the
data_hash by all clients. At a given value for data_hash E will
always be the same. The data_hash is a truncated SHA-1 hash of
properties of the entityAn attribute will be added to E called ‘h’, and a python property
will be added to your class to access this value as rev_hash. This
value is added to your entity to allow you to track which revision
the current entity is at. The rev_hash is a truncated SHA-1 hash of
parent rev_hash, account string, and data_hash properties of the
entityNo other properties will be added to E, instead you will have to
fetch the audit entities – this is to keep overhead on E as small as
possibleUsageTODO
Package: ndbcrealtime
NOAA NDBC-API (ndbcrealtime)PyPi Integration to the NOAA National Data Buoy Centre real time observations for wind, waves, sea level pressure, air temperature, water temperature, dewpoint, visibility, pressure tendency, and tide information (as available) for a specific buoy.Available Classes and MethodsClass NDBC(station_id, session (optional))Create an instance of the NDBC class with a specific station_id in order to retrieve the current observation data usingget_data()station_id (string):the station id for the buoy which can be found from the NDBC website:https://www.ndbc.noaa.gov/Session can be sent as an optional aiohttp session if you are managing your session within an application.get_data()Returns the current observation data as a JSON object.Return PayloadThe payload returned will be structured as:{"location":{"latitude":latitude(float),"longitude":longitude(float),"elevation":elevation(int),"name":stationname(str)},"observation":{"time":{"utc_time":utcdate/time(datetime),"unix_time":unixtimestamp(int)},"wind":{"direction":winddirection(int),"direction_unit":directionunits(str),"direction_compass":directiontext(str),"speed":windspeed(float),"speed_unit":speedunits(str),"gusts":windgusts(float),"gusts_unit":gustsunits(str)},"waves":{"height":waveheight(float),"height_unit":waveheightunits(str),"period":dominantwaveperiod(int),"period_unit":waveperiodunits(str),"average_period":averagewaveperiod(int),"average_period_unit":averageperiodunits(str),"direction":dominantwavedirection(int),"direction_unit":dominantdirectionunits(str),"direction_compass":directiontext(str)},"weather":{"pressure":sealevelpressure(float),"pressure_unit":pressureunits(str),"air_temperature":airtemperature(float),"air_temperature_unit":airtemperatureunits(str),"water_temperature":watertemperature(float),"water_temperature_unit":watertemperatureunits(str),"dewpoint":dewpointtemperature(float),"dewpoint_unit":dewpoint_units(str),"visibility":visibility(float),"visibility_unit":visibilityunits(str),"pressure_tendency":pressuretendency(float),"pressure_tendency_unit":pressuretendencyunits(str),"tide":tide(float),"tide_unit":tideunits(float)}}}Class Stations()Create an instance of the Stations class to retrieve a list of available stations from the NDBC database.list()Returns a dict containing all available NDBC stations.Return PayloadThe payload returned will be structured as:{'00922':{'@id':'00922','@lat':'30','@lon':'-90','@name':'OTN201-4800922','@owner':'DalhousieUniversity','@pgm':'IOOSPartners','@type':'other','@met':'n','@currents':'n','@waterquality':'n','@dart':'n'},...}Note: This library was built specifically for integration to Home Assistant.
Package: ndbioimage
ndbioimage - Work in progressExposes (bio) images as a numpy ndarray-like object, but without loading the whole
image into memory, reading from the file only when needed. Some metadata is read
and stored in anomestructure.
Additionally, it can automatically calculate an affine transform that corrects for chromatic aberrations etc. and apply
it on the fly to the image.Currently, it supports imagej tif files, czi files, micromanager tif sequences and anythingbioformatscan handle.Installationpip install ndbioimageUsageReading an image file and plotting the frame at channel=2, time=1import matplotlib.pyplot as plt
from ndbioimage import Imread
with Imread('image_file.tif', axes='ctxy', dtype=int) as im:
    plt.imshow(im[2, 1])Showing some image metadatafrom ndbioimage import Imread
from pprint import pprint
with Imread('image_file.tif') as im:
    pprint(im)Slicing the image without loading the image into memoryfrom ndbioimage import Imread
with Imread('image_file.tif', axes='cztxy') as im:
    sliced_im = im[1, :, :, 100:200, 100:200]sliced_im is an instance of Imread which will load any image data from file only when neededConverting (part) of the image to a numpy ndarrayfrom ndbioimage import Imread
import numpy as np
with Imread('image_file.tif', axes='cztxy') as im:
    array = np.asarray(im[0, 0])Adding more formatsReaders for image formats subclass AbstractReader. When an image reader is imported, Imread will
automatically recognize it and use it to open the appropriate file format. Image readers
are required to implement the following methods:staticmethod _can_open(path): return True if path can be opened by this readerproperty ome: reads metadata from file and adds them to an OME object imported
from the ome-types library__frame__(self, c, z, t): return the frame at channel=c, z-slice=z, time=t from the fileOptional methods:open(self): maybe open some file handleclose(self): close any file handlesOptional fields:priority (int): Imread will try readers with a lower number first, default: 99do_not_pickle (strings): any attributes that should not be included when the object is pickled,
for example: any file handlesTODOmore image formats
Package: ndbpager
# Pager (pagination) for Google Appengine NDBThis is pager for Google Appengine NDB that caches cursor in memcache.# ExampleThere is an example for Flask athttps://github.com/vmihailenco/ndbpager-example/:
-https://github.com/vmihailenco/ndbpager-example/tree/master/app/blog/views.py-https://github.com/vmihailenco/ndbpager-example/tree/master/app/blog/templates/pager.html-https://github.com/vmihailenco/ndbpager-example/tree/master/app/blog/templates/blog/article_list.html