Saravanan666/pypi-org huggingface dataset:
Package: xapiparser
XAPI ssh command parser to convert cli commands to xml for use in the Cisco XAPI REST APIFree software: MIT licenseInstallationpip install xapiparserYou can also install the in-development version with:pip install https://github.com/jonathanelscpt/xapiparser/archive/master.zipDocumentationTo use the project:importxapiparserxapi='xConfiguration Conference Encryption Mode'xapiparser.parse(xapi)DevelopmentTo run all the tests run:toxNote, to combine the coverage data from all the tox environments run:Windowsset PYTEST_ADDOPTS=--cov-append
toxOtherPYTEST_ADDOPTS=--cov-append toxChangelog0.0.14 (2020-09-28)fixed build token encryption issues with travis-ci.com0.0.11 (2020-09-28)updated build auto-deploy settings0.0.10 (2020-09-28)fixed exception raising behaviouradded unit testsrenamed references to refer to ‘cmd’updated travis-ci settings to use .com instead of .org site0.0.9 (2020-09-28)added typing supportbuild bug fixes.0.0.8 (2020-09-26)build and deployment automation with travis.0.0.7 (2020-09-26)trivial bug fixes0.0.6 (2020-09-26)fixed basic case defect and added unit testing0.0.5 (2020-09-26)fixed bugs in cli tool0.0.4 (2020-09-26)updated supported, ssh-only and currently supported ssh cmds0.0.3 (2020-09-25)fixed metavar issue with cli tool and added test coverage0.0.2 (2020-09-25)first release on PyPI.
Package: xapo_sdk
Xapo’s bitcoin sdk & toolsThis is the Python version of the Xapo’s SDK & Widget Tools. These tools allow you (Third Party Application, TPA) to easily develop your bitcoins applications to manageAccounts, Wallets, Transactions, etc., or embed tools likePayments Buttons, Donation Buttonsand other kind of widgets into your web application using your language of choice. In this way, tedious details like encryption and HTML snippet generation are handled for you in a simple and transparent way.Free software: BSD licenseDocumentation:http://xapo-sdk.readthedocs.org.FeaturesIframeandDivHTML widgets snippet generator.History0.2.2 (2014-11-14)Added customization options and callbacks to Xapo micro payment tool.0.2.1 (2014-11-04)Added xapo_api module, including the credit api v0 (this is about to change soon in the incoming v1 api).Introduced xapo_tool.PaymentType constants.0.2.0 (2014-11-01)Having a TPA is not longer mandatory to provide a micro payments widget. Parameters app_id and app_secret are now optional.0.0.1 (2014-10-18)First release on PyPI.Includes:iframe widgetdiv widget
Package: xappt-qt
Xappt_QTQt/PyQt5 interface plugin forXapptExamplesXappt_QT ships with a few example plugins that you can dissect. To load these plugins set an environment variable named XAPPT_LOAD_EXAMPLE_TOOLS to "1" before loading Xappt_QT.$exportXAPPT_LOAD_EXAMPLE_TOOLS=1These examples can be found inxappt_qt.plugins.tools.examples.
Package: xappy
The “xappy” python module is an easy-to-use interface to the Xapian search
engine. Xapian provides a low level interface, dealing with terms and
documents, but not really worrying about where terms come from, or how to build
searches to match the way in which data has been indexed. In contrast, “xappy”
allows you to design a field structure, specifying what kind of information is
held in particular fields, and then uses this field structure to index data
appropriately, and to build and perform searches.Xappy is not yet stable - in particular, both the API and database format will
change in future releases.   If you wish to use it, we recommend that you
subscribe to the xappy-discuss mailing list (seehttp://groups.google.com/group/xappy-discuss) to keep up-to-date with changes
to Xappy.
Package: xapres
xapresA package for processing data from the Autonomous phase-sensitive Radio-Echo Sounder (ApRES) using xarray. The core ApRES processing code is adapted from code written by Keith Nicholls, British Antarctic Survey, UK. This package uses Keith's code to process the raw ApRES data from ApRES surveys. It then restructures the data into a convenient format using xarray. This simplifies the challenge of dealing with multiple attenuator and gain settings, makes stacking a straight-forward xarray operation, and allows us to store the large datasets in efficient zarr format in cloud storage.The structure of the resulting xarray depends on if the ApRES data were collected in attended or unattended mode.Installationpip install xapresUsageSee the notebooks/guides directory for examples of how to use both the core processing code and how to restructure the resulting profiles and chirps into an xarray.The most useful guide is notebooks/guides/UsingXaPRES.ipynb.The package includes the capability to write data to zarr stores, which can be accessed efficiently without immediately loading all the data to disk. This is particularly useful when performing analysis in the cloud, but can be useful when inspecting the data locally too.For example, to lazily access (meaning that no data is downloaded immediately) some recent ApRES data from Greenland, use:import xarray as xr
def reload(site):
    filename = f'gs://ldeo-glaciology/apres/greenland/2022/single_zarrs_noencode/{site}'
    ds = xr.open_dataset(filename,
        engine='zarr', 
        chunks={}) 
    return ds
A101 = reload("A101")
A103 = reload("A103")
A104 = reload("A104")Alternatively, you can use a function built-in to the package which loads these data, and also adds some functionality to the xarray it returns:import xapres as xa
ds = xa.load.load_zarr(site="A101")
dsThe datasetdscontaining various variables, include the complex depth profile. You can compute decibels from complex depth profiles usingds.profile.dB().compute()You can also sonify the chirp. Because the frequencies contained in the chirps largely in the audible range, you can play them through the computer's speakers and hear what the ApRES data sound like:ds.chirp.isel(time=300, chirp_num=0, attenuator_setting_pair=0).sonify()This plays the chirp and if you setsave = Trueas an input it will save the audio file as a .wav file.Contributions to this project are very welcome! Please feel free to contact us through github issues.Project based on thecookiecutter science project template.
Package: xarg-python
xargSimple command-line tool based onargparse.Language简体中文FeaturesQuickly create command line programs based onPythonBuilt in logger module and management optionsManage completion viaxargcompleteRequiresPython>= 3.8BuildFast build and install viaxpip:xpip-buildsetup--clean--all--installor build via shell:rm-rf"build""dist""*.egg-info"pythonsetup.pychecksdistbdist_wheel--universal
Package: xargsd
Likexargs, but accepts arguments from arbitrary processes, and executes eagerly as long as there are arguments available.That is to say,xargsd [...] -- foobar, when it receives argumentsaandb, will executefoobar a b. If argumentscthroughfarrive whilefoobar a bis executing, thenfoobar c d e fwill get run as soon as the first invocation finishes.ExamplesA toy example, demonstrating the very basic functionality:$python-mxargsd--socket-filetemp.sock-vvv--echo&[1]14917$submit(){python-mxargsd.client--socket-filetemp.sock--"$@";}$submita
INFO:root:executing['echo','a']a
$submitbcd
INFO:root:executing['echo','b','c','d']bcd(Note that theINFO:lines and the following ones are printed byxargsd, not the client.)A slightly-less-toy example, which demonstrates how commands are batched up while a previous command is executing:$echo'date; sleep "$@"'>date-and-sleep.sh
$python-mxargsd--socket-filetemp.sock-vvv--bashdate-and-sleep.sh&[4]15714$submit(){echo"submitting$@";python-mxargsd.client--socket-filetemp.sock--"$@";}$submit1;sleep0.1;submit0.99;sleep0.1;submit1.01;sleep3submitting1INFO:root:executing['bash','date-and-sleep.sh','1']SunMay1209:53:13PDT2019submitting0.99
submitting1.01
DEBUG:root:finishedexecuting['bash','date-and-sleep.sh','1']:status0INFO:root:executing['bash','date-and-sleep.sh','0.99','1.01']SunMay1209:53:14PDT2019DEBUG:root:finishedexecuting['bash','date-and-sleep.sh','0.99','1.01']:status0A completely serious example, usingwatchmanto runxargsd.clientwhenever a file (whose name matches some pattern) changes:$watchmanwatch.
$watchman--trigger.pytest-p'.*\.py$'-X-p'(^|.*/)\.'--bash-c'python -m xargsd.client --socket-file .xargsd-pytest.sock -- .'$python-mxargsd--unique--socket-file.xargsd-pytest.sock-vvv--pytest--color=yesThen save a.pyfile and watch the daemon executepytest .
Package: xarr
astoDeveloper GuideSetup# create conda environment$mambaenvcreate-fenv.yml# update conda environment$mambaenvupdate-nasto--fileenv.ymlInstallpipinstall-e.# install from pypipipinstallastonbdev# activate conda environment$condaactivateasto# make sure the asto package is installed in development mode$pipinstall-e.# make changes under nbs/ directory# ...# compile to have changes apply to the asto package$nbdev_preparePublishing# publish to pypi$nbdev_pypi# publish to conda$nbdev_conda--build_args'-c conda-forge'$nbdev_conda--mambabuild--build_args'-c conda-forge -c dsm-72'UsageInstallationInstall latest from the GitHubrepository:$pipinstallgit+https://github.com/dsm-72/asto.gitor fromconda$condainstall-cdsm-72astoor frompypi$pipinstallastoDocumentationDocumentation can be found hosted on GitHubrepositorypages. Additionally you can find
package manager specific guidelines oncondaandpypirespectively.
Package: xarray-ceos-alos2
xarray-ceos-alos2Read ALOS2 CEOS files intodatatreeobjects.InstallationFrom PyPIpipinstallxarray-ceos-alos2From conda-forgecondainstall-cconda-forgexarray-ceos-alos2Usageimportceos_alos2tree=ceos_alos2.open_alos2(url,chunks={},backend_options={"requests_per_chunk":4096})
Package: xarray-compare
xarray-comparexarray extension for data comparisonTL;DRxarray-compare is a third-party Python package which provides extra data-comparison features.
After importing the package, several DataArray methods (dataarray.is*()) will be available.RequirementsPython:3.6, 3.7, or 3.8 (tested by the author)Dependencies:Seepyproject.tomlInstallation$pipinstallxarray-compareList of available methods.isbetween(lower, upper): Test whether each value in a DataArray falls within an interval.ismatch(pattern): Test whether each string in a DataArray matches a regex patternMethods of "not-in" version are also provided for readability..isnotin(values): Equivalent to~dataarray.isin(values)(.isin()is an xarray's builtin).isnotbetween(lower, upper): Equivalent to~dataarray.isbetween(lower, upper).isnotmatch(pattern): Equivalent to~dataarray.ismatch(pattern)Examplesxarray-compare is a just-import package.
After importing it, methods become available from normal DataArray instances.importxarrayasxrimportxarray_compareA method returns a boolean DataArray each value of which isTruewhere that of the input DataArray fulfills the condition andFalseotherwise.
This is why it works well with thedataarray.where()method.da=xr.DataArray([0,1,1,2,3,5,8,13])da.where(da.isbetween(1,4),drop=True)# <xarray.DataArray (dim_0: 4)># array([1., 1., 2., 3.])# Dimensions without coordinates: dim_0da=xr.DataArray(['a','aa','ab','bc'])da.where(da.ismatch("^a+$"),drop=True)# <xarray.DataArray (dim_0: 2)># array(['a', 'aa'], dtype=object)# Dimensions without coordinates: dim_0
Package: xarray-custom
xarray-custom:zap: Data classes for custom xarray creationTL;DRxarray-custom is a third-party Python package which helps to create custom DataArray classes in the same manner asthe Python's native dataclass.
Here is an introduction code of what the package provides:fromxarray_customimportcoord,dataarrayclass@dataarrayclassclassImage:"""DataArray class to represent images."""dims='x','y'dtype=floataccessor='img'x:coord('x',int)=0y:coord('y',int)=0defnormalize(self):returnself/self.max()The key features are:# create a custom DataArrayimage=Image([[0,1],[2,3]],x=[0,1],y=[0,1])# use a custom method via an accessornormalized=image.img.normalize()# create a custom DataArray filled with onesones=Image.ones((2,2),x=[0,1],y=[0,1])Custom DataArray instances with fixed dimensions, datatype, and coordinates can easily be created.NumPy-like special functions likeones()are provided as class methods.Custom DataArray methods can be available via a custom accessor.RequirementsPython:3.6, 3.7, or 3.8 (tested by the author)Dependencies:Seepyproject.tomlInstallation$pipinstallxarray-customLicenseCopyright (c) 2020 Akio Taniguchixarray-custom is distributed under the MIT Licensexarray-custom uses an icon ofxarraydistributed under the Apache 2.0 license
Package: xarray-datatree
datatreeCIDocsPackageLicenseDatatree is a prototype implementation of a tree-like hierarchical data structure for xarray.Datatree was born after the xarray team recognised aneed for a new hierarchical data structure,
that was more flexible than a singlexarray.Datasetobject.
The initial motivation was to represent netCDF files / Zarr stores with multiple nested groups in a single in-memory object,
butdatatree.DataTreeobjects have many other uses.InstallationYou can install datatree via pip:pipinstallxarray-datatreeor via conda-forgecondainstall-cconda-forgexarray-datatreeWhy Datatree?You might want to use datatree for:Organising many related datasets, e.g. results of the same experiment with different parameters, or simulations of the same system using different models,Analysing similar data at multiple resolutions simultaneously, such as when doing a convergence study,Comparing heterogenous but related data, such as experimental and theoretical data,I/O with nested data formats such as netCDF / Zarr groups.Talk slides on Datatree from AMS-python 2023FeaturesThe approach used here is based on benbovy'sDatasetNodeexample- the basic idea is that each tree node wraps a up to a singlexarray.Dataset. The differences are that this effort:Uses a node structure inspired byanytreefor the tree,Implements path-like getting and setting,Has functions for mapping user-supplied functions over every node in the tree,Automatically dispatchessomeofxarray.Dataset's API over every node in the tree (such as.isel),Has a bunch of tests,Has a printable representation that currently looks like this:Get StartedYou can create aDataTreeobject in 3 ways:Load from a netCDF file (or Zarr store) that has groups viaopen_datatree().Using the init method ofDataTree, which creates an individual node.
You can then specify the nodes' relationships to one other, either by setting.parentand.childrenattributes,
or through__get/setitem__access, e.g.dt['path/to/node'] = DataTree().Create a tree from a dictionary of paths to datasets usingDataTree.from_dict().Development RoadmapDatatree currently lives in a separate repository to the main xarray package.
This allows the datatree developers to make changes to it, experiment, and improve it faster.Eventually we plan to fully integrate datatree upstream into xarray's main codebase, at which point thegithub.com/xarray-contrib/datatreerepository will be archived.
This should not cause much disruption to code that depends on datatree - you will likely only have to change the import line (i.e. fromfrom datatree import DataTreetofrom xarray import DataTree).However, until this full integration occurs, datatree's API should not be considered to have the samelevel of stability as xarray's.User FeedbackWe really really really want to hear your opinions on datatree!
At this point in development, user feedback is critical to help us create something that will suit everyone's needs.
Please raise any thoughts, issues, suggestions or bugs, no matter how small or large, on thegithub issue tracker.
Package: xarray-einstats
xarray-einstatsStats, linear algebra and einops for xarrayInstallationTo install, run(.venv) $ pip install xarray-einstatsSee the docs for moreextensive install instructions.OverviewAs stated in their website:xarray makes working with multi-dimensional labeled arrays simple, efficient and fun!The code is often more verbose, but it is generally because it is clearer and thus less error prone
and more intuitive.
Here are some examples of such trade-off where we believe the increased clarity is worth
the extra characters:numpyxarraya[2, 5]da.sel(drug="paracetamol", subject=5)a.mean(axis=(0, 1))da.mean(dim=("chain", "draw"))a.reshape((-1, 10))da.stack(sample=("chain", "draw"))a.transpose(2, 0, 1)da.transpose("drug", "chain", "draw")In some other cases however, using xarray can result in overly verbose code
that often also becomes less clear.xarray_einstatsprovides wrappers
around some numpy and scipy functions (mostlynumpy.linalgandscipy.stats)
and aroundeinopswith an api and features adapted to xarray.
Continue at thegetting started page.Contributingxarray-einstats is in active development and all types of contributions are welcome!
See thecontributing guidefor details on how to contribute.Relevant linksDocumentation:https://einstats.python.arviz.org/en/latest/Contributing guide:https://einstats.python.arviz.org/en/latest/contributing/overview.htmlArviZ project website:https://www.arviz.orgSimilar projectsHere we list some similar projects we know of. Note that all of
them are complementary and don't overlap:xr-scipyxarray-extrasxhistogramxrftCite xarray-einstatsIf you use this software, please cite it using the following template and the version
specific DOI provided by Zenodo. Click on the badge to go to the Zenodo page
and select the DOI corresponding to the version you usedOriol Abril-Pla. (2022). arviz-devs/xarray-einstats<version>. Zenodo.<version_doi>or in bibtex format:@software{xarray_einstats2022,
  author       = {Abril-Pla, Oriol},
  title        = {{xarray-einstats}},
  year         = 2022,
  url          = {https://github.com/arviz-devs/xarray-einstats}
  publisher    = {Zenodo},
  version      = {<version>},
  doi          = {<version_doi>},
}
Package: xarray-events
xarray-events: An open-source extension of xarray that supports events handlingxarray-eventsis an open-source API based onxarray. It provides
sophisticated mechanisms to handleeventseasily.Events data is something very natural to conceive, yet it’s rather infrequent to
see native support for it in common data analysis libraries. Our aim is to fill
this gap in a very general way, so that scientists from any domain can take
benefit from this. We’re building all of this on top ofxarraybecause
this is already a well-established open-source library that provides exciting
new ways of handling multi-dimensional labelled data, with applications in a
wide range of domains of science.This library makes it possible toextendaDatasetby introducing
events based on the data. Internally it works as anaccessortoxarraythat provides new methods to deal with new data in the form of events and also
extends the existing ones already provided by it to add compatibility with this
new kind of data.We hope that this project inspires you to rethink how you currently handle data
and, if needed, improve it.ExampleAssume we have aDataFrame(in a variable calledds) of events and aDataset(in a variable calledevents) of sports data in such a way that
the events are a meaningful complement to the data stored in theDataset.events=pd.DataFrame({'event_type':['pass','goal','pass','pass'],'start_frame':[1,175,251,376],'end_frame':[174,250,375,500]})ds=xr.Dataset(data_vars={'ball_trajectory':(['frame','cartesian_coords'],np.exp(np.linspace((-6,-8),(3,2),500)))},coords={'frame':np.arange(1,501),'cartesian_coords':['x','y']},attrs={'match_id':12,'resolution_fps':25,'_events':events})With this API we can do the following:ds.events.load(events,{'frame':('start_frame','end_frame')}).events.sel({'frame':range(175,376),'start_frame':lambdaframe:frame>=175,'end_frame':lambdaframe:frame<376}).events.groupby_events('ball_trajectory').mean()This will:Load the events DataFrame specifying that the columnsstart_frameandend_framedefine the span of the events as per the Dataset’s coordinateframe.Perform a selection constraining the frames to be only in the range
[175, 375].Group theDataVariableball_trajectoryby the events.Compute themeanof each group.<xarray.DataArray'ball_trajectory'(event_index:2,cartesian_coords:2)>array([[0.12144595,0.02556095],[0.84426861,0.22346441]])Coordinates:*cartesian_coords(cartesian_coords)<U1'x''y'*event_index(event_index)int6412This result can be interpreted as the mean 2D position of the ball over the span
of each event during the frames [175, 375]. This is a very powerful set of
operations performed via some simple and intuitive function calls. This is the
beauty of this API.
Package: xarray-fancy-repr
Xarray Fancy ReprThis package provides enhanced representations of Xarray objects (Dataset,
DataArray, Coordinates and Variable) for a better and more interactive user
experience within Jupyter notebooks.Installationpipinstallxarray-fancy-reprHow Does it Work?After importing this package:importxarray_fancy_reprXarray objects are patched so that they are displayed in the following fallback
order:Interactive widget: should work in most notebook environments (JupyterLab,
Jupyter Notebook <7 and 7+, Google Colab, VSCode, etc.) based onanywidgetStatic HTML: should work in any web browserPlain text
Package: xarrayfrac
xarrayfracA dynamic generative mandelbrot custom backend for xarraypip install xarrayfracimport numpy as np
import xarray as xr
from matplotlib import pyplot as plt

# request a 10 billion pixel lazy xarray fractal
ds = xr.open_dataset(None, engine="xarrayfrac", resolution=100000, chunks={"x": 2000, "y": 2000})
# sample 1 in every 10000 pixels
sampled = ds.frac.isel(x=slice(0, 100000, 100), y=slice(0, 100000, 100))
# compute and display
plt.imshow(sampled)# request a 10 billion pixel lazy xarray fractal
ds = xr.open_dataset(None, engine="xarrayfrac", resolution=100000, chunks={"x": 2000, "y": 2000})
# zoom 
window = ds.sel(x=slice(-0.1, 0.1), y=slice(0.9, 1.0))
# plot every hundredth pixel of the window
plt.imshow(window.frac[::10, ::10])
Package: xarray_leaflet
xarray-leaflet: an xarray extension for tiled map plottingxarrayandLeafletshare this ability to work with fragments of data, xarray through Dask's chunks, and Leaflet through map tiles. In the end this is really the same concept, so it was a natural thing to make them work together.Fortunately xarray is written in Python, and we happen to have a great Python binding for Leaflet,ipyleaflet.xarray-leaflet uses ipyleaflet as a plotting backend for data arrays. It generates map tiles on the fly, possibly using Dask's lazy evaluation system and Zarr's chunked data storage, and serves them through the Jupyter server, allowing for big data visualization.See the example notebooks:examples/introduction.ipynbto get started.examples/dynamic.ipynbfor more advanced visualizations, and in particular dynamic maps.examples/custom_projection.ipynbfor an example of non-Mercator projection.How does it compare to other visualization libraries?xarray-leaflet doesn't try to reinvent the wheel. It stands on the shoulders of giants: xarray, Jupyter widgets, Leaflet. By combining this software stack, it opens up new possibilities while being a relatively small library.InstallationUsing conda:condainstall-cconda-forgexarray_leafletUsing pip:pipinstallxarray_leafletUsing xarray-leaflet with VoilaTo work with xarray-leaflet, Voila has to be launched with the following command:jupyterserver--ServerApp.open_browser=True--ServerApp.default_url="voila/render/path_to_notebook.ipynb"