Saravanan666/pypi-org huggingface dataset:
Package: hyper-shell
HyperShellis an elegant, cross-platform, high-performance computing utility for
processing shell commands over a distributed, asynchronous queue. It is a highly
scalable workflow automation tool formany-taskscenarios.Several tools offer similar functionality but not all together in a single tool with
the ergonomics we provide. Novel design elements include but are not limited to
(1) cross-platform, (2) client-server design, (3) staggered launch for large scales,
(4) persistent hosting of the server, and optionally (5) a database in-the-loop for
persisting task metadata and automated retries.HyperShellis pure Python and is tested on Linux, macOS, and Windows 10 in
Python 3.9+ environments. The server and client don’t even need to use the same
platform simultaneously.DocumentationDocumentation is available athyper-shell.readthedocs.io.
For basic usage information on the command line use:hyper-shell--help. For a more
comprehensive usage guide on the command line you can view the manual page withmanhyper-shell.ContributionsContributions are welcome. If you find bugs or have questions, open anIssuehere.
We’ve added a Code of Conduct recently, adapted from theContributor Covenant, version 2.0.CitationIfHyperShellhas helped in your research please consider citing us.@inproceedings{lentner_2022,author={Lentner, Geoffrey and Gorenstein, Lev},title={HyperShell v2: Distributed Task Execution for HPC},year={2022},isbn={9781450391610},publisher={Association for Computing Machinery},url={https://doi.org/10.1145/3491418.3535138},doi={10.1145/3491418.3535138},booktitle={Practice and Experience in Advanced Research Computing},articleno={80},numpages={3},series={PEARC '22}}
Package: hypersindy
HyperSINDyThis repository is the official implementation of HyperSINDy, first introduced inHyperSINDy: Deep Generative Modeling of Nonlinear Stochastic Governing Equations.RequirementsAll the requirements are contained in the environment.yml file\
To install the requirements, run:conda env create -f environment.ymlThen, activate the conda environment:conda activate hypersindyOr, with some conda environment that can run Python 3.9, you can manually install
the dependencies:conda install scipy seaborn tensorboard matplotlib scikit-learn pandas jupyterlab pip
pip3 install pysindy torch==1.12.0 torchvisionInstallationAfter installing dependencies, you can install hypersindy:pip3 install hypersindyExample use caseSee example.py as well.
``
python3from hypersindy.library import Library
from hypersindy.net import Net
from hypersindy.trainer import Trainer
from hypersindy.dataset import SyntheticDataset
from hypersindy.utils import set_random_seedset_random_seed(0)
device = 2
x_dim = 3
z_dim = 6
data_path = 'x_train.npy'library = Library(x_dim)
net = Net(library, z_dim).to(device)
dataset = SyntheticDataset(library, fpath=data_path)
trainer = Trainer(net, library, "runs/1", "runs/1.pt", device=device)
trainer.train(dataset)equations
results
``Results can be viewed in tensorboard.tensorboard --logdir="runs"PaperTo reproduce results from the paper, go to the paper folder and view the README there.cd paper
Package: hypersolver
hyper(bolic partial differential equations)solverhelp(hypersolver) for use info, etc.—hypersolver revolves around solving hyperbolic
partial differential equations (PDEs) of the form∂n/∂t + ∂(fn)/∂x = ∂n/∂t + f ∂n/∂x + n ∂f/∂x = gwheren is a property of interest,
x is an independent variable of interest,
f is speed n moves along x, and
g lumps sources and sinksfunctionally, n(x; t), f(x), and g(n; x)note, fn is the flux across x—contributions to expand functionality are welcome!e.g. allowing f(x) to be f(n; x) is ~easy
Package: hypersParaer
paraerPython Boilerplate contains all the boilerplate you need to create a Python package.Free software: MIT licenseDocumentation:https://paraer.readthedocs.io.Features支持api参数校验,并且当多个参数输入不合法时，会收集多个参数的校验后的提示信息一并返回，而不是当有一个参数非法时立即返回支持api导出为markdown文档，可通过pandoc转为其他格式支持通过api直接生成swagger文档,完美对接django-restframework-swagger支持根据ViewSet或者APIView中定义的serializer_class自动生成swagger的http code为200时的返回格式支持ViewSet中的list方法自动生成分页参数支持当参数为枚举值时，在description中定义枚举值的choices，可以自动生成swagger的表格CreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2018-05-07)First release on PyPI.
Package: hyperspectral
This is a frugal python package with some hyperspectral data goodies.
The whole source, including tests, can be found
[on github](https://github.com/irap-omp/hyperspectral).How to installThe setup script is build atopdistutils, so you can read the
[official documentation](https://docs.python.org/2/install/index.html#the-new-standard-distutils)
for installation instructions.To summarize, you can install viapipor via thesetupscript :` pip install hyperspectral `or` python setup.py install `How to publishCopy.pypircto~/.pypirc. Fill out thepasswordfield. (ask me !)` python setup.py sdist && twine upload dist/* `Dependencies[astropy](http://www.astropy.org)[numpy](http://www.numpy.org)If you runsetup.py, you’ll need
[distutils](https://docs.python.org/2/install/index.html) too.Testing DependenciesYou don’t need those unless you’re running the test suite.[unittest](https://docs.python.org/2/library/unittest.html)[ddt](https://github.com/txels/ddt)Hyperspectral CubeA wrapper for 3D data with two spatial dimensions and one spectral dimension.
It extendsastropy.nddata.NDDataand makes a heavy usage ofastropy.units.
It main purpose is to sanitize and uniformize hyperspectral cubes from FITS
files that were made by careless astronomers, with header cards (FITS metadata)
ranging from exotic to blatantly illegal.
Package: hyperspectralpy
Python tools with a GUI for visualization and analysis (target detection, PCA, material identification, library management) involving multispectral and hyperspectral images.-User guide athttps://github.com/wbasener/hyperspectralpy/blob/main/Spectral%20Tools%20User%20Guide.pdf-To run with the GUI do "pip install hyperspectralpy" from the command line and then "import hyperspectralpy" from Python.-There is a demo on YouTube at:https://youtube.com/playlist?list=PLzUi-TW1M9mrxAZGKlCwsFzHDv4y3030B
Package: hyperspy
HyperSpy is an open source Python library for the interactive analysis of
multidimensional datasets that can be described as multidimensional arrays
of a given signal (for example, a 2D array of spectra, also known as a
spectrum image).HyperSpy makes it straightforward to apply analytical procedures that
operate on an individual signal to multidimensional arrays, as well as
providing easy access to analytical tools that exploit the multidimensionality
of the dataset.Its modular structure makes it easy to add features to analyze many different
types of signals.HyperSpy is released under the GPL v3 license.Since version 0.8.4, HyperSpy only supports Python 3.If you need to install
HyperSpy in Python 2.7, please install version 0.8.3.ContributingEveryone is welcome to contribute. Please read ourcontributing guidelinesand get started!
Package: hyperspy-gui-ipywidgets
hyperspy_gui_ipywidgetshyperspy_gui_ipywidgetsprovides ipywidgets graphic user interface (GUI) elements for hyperspy.InstallationOption 1: With pipMake sure you havepip installedand run:pipinstallhyperspy_gui_ipywidgetsOption 2: With AnacondaInstall anaconda for your platform and runcondainstallhyperspy-gui-ipywidgets-cconda-forgeRunning the testspy.test is required to run the tests.pipinstall"hyperspy_gui_ipywidgets[test]"py.test--pyargshyperspy_gui_ipywidgetsUsagePlease refer to theHyperSpy documentationfor details. Example (to run in theJupyter Notebook):importhyperspy.apiashshs.preferences.gui(toolkit="ipywidgets")DevelopmentContributions through pull requests are welcome. See theHyperSpy Developer Guide.
Package: hyperspy-gui-traitsui
hyperspy_gui_traitsuiprovides traitsui graphic user interface (GUI) elements for hyperspy.InstallationOption 1: With pipMake sure you havepip installedand run:pipinstallhyperspy_gui_traitsuiOption 2: With AnacondaInstall anaconda for your platform and runcondainstallhyperspy-gui-traitsui-cconda-forgeUsagePlease refer to theHyperSpy documentationfor details. Example (to run in any jupyter flavour):%matplotlibqtimporthyperspy.apiashshs.preferences.gui(toolkit="traitsui")DevelopmentContributions through pull requests are welcome. See theHyperSpy Developer Guide.
Package: hyperspyUI
HyperSpyUIHyperSpyUI tries to bring a streamlined user interface to the powerful
multi-dimensional analysis capabilities ofHyperSpy. HyperSpy is an open
source Python library which provides tools to facilitate data analysis of
multidimensional datasets.HyperSpy aims at making it easy and natural to apply analytical procedures
that operate on an individual signal to multidimensional arrays, as well as
providing easy access to analytical tools that exploit the multidimensionality
of the dataset.While the UI tries to create a simple and intuitive interface to HyperSpy, it
still retains the raw power of HyperSpy via the UI’s built in IPython console,
which runs on the same Python kernel as the UI.DocumentationFor an introduction to HyperSpyUI, see thedocumentation.InstallationThere are several ways to install HyperSpyUI. The application itself is rather
simple to install, but its dependencies can be a bit more tricky. From version
1.1, HyperSpyUI supports both PyQt4 and PyQt5.HyperSpy Bundle InstallerThe quickest way to get set up is to download and install
theHyperSpy bundleinstaller, which includes HyperSpyUI.Anaconda/Miniconda/MiniforgeDownload and install theMiniforge(MinicondaorAnaconda) distribution
and run the following command in the anaconda prompt:condainstall-cconda-forgehyperspyuiInstallation via pipHyperSpyUI can be intall from pip. Depending on your python distribution you may
need to have C compiler on your system to install some of the dependencies.pipinstallhyperspyuiIf pyqt is not installed, run:pipinstallPyQt5PyQtWebEngineRun HyperSpyUIAfter installation, you can run HyperSpyUI from the command prompt with:hyperspyuiorpython-mhyperspyuiFor further information, see the fulldocumentation.
Package: hypersquirrel
hypersquirrelUsageModulepipinstallhypersquirrelfromhypersquirrelimportscrapeforfileinscrape("scrape_url"):print(file)Standalonedocker-composeup--build-dcurl--location--requestPOST'localhost:5000/scrape'\--header'Content-Type: application/json'\--data-raw'{ "url": "scrape_url" }'
Package: hypersrabbit
hypersrabbitPython Boilerplate contains all the boilerplate you need to create a Python package.Free software: MIT licenseDocumentation:https://hypersrabbit.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2018-12-29)First release on PyPI.
Package: hyper-status
hyper-statusA status indicator that you can modify.examples-ChangelogExamples# Custom print exampleStatus('This is a test warning. Be warned!','warn')Status('Oh no, something has totally failed!','fail')Status('This is fine. Everything is fine.','ok')Status('Something happened.')Status()Changelogv1.3:Changed:Put 0's back for now in timestamps so all statuses are aligned.v1.2:Changed:Fixed bug where time wouldn't change after Status is called multiple times.v1.1:Changed:The way this package is imported. Fromfrom hyper_status.status import Statustofrom hyper_status import Statusv1.0:Added:Ability to change colors just by editing the module's color dictionary after importing.You don't need to put anything at all in the Status, and it will print just the date.Changed:Amounts of colors, and the statuses that go with them.Where the status is placed. The warning string is now the first priority.Removed:Wrapper for catching errors, since a person should know how to catch errors and then use this package.v0.2:Added:Wrapper that now catches any incorrect indexes of colors.If status file is called, then there will be some examples of what you can get out of the status.Changed:Comments for readability.Colors within the timestamps.Different formatting for the change log.Removed:0s before times in timestamps.v0.1:Added:Files imported fromXythrion.Changed:How the comments are formatted.Removed:Useless classmethods that didn't do anything useful.
Package: hypersxlsx
hypersxlsxhypers 用于写excel的库Free software: MIT licenseDocumentation:https://hypersxlsx.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2018-06-27)First release on PyPI.
Package: hyper-systems
hyper-python-sdkPython SDK for interacting with the Hyper.systems platform.Checkherefor usage and other documentation.Pypi.org:InstallingInstall the latest version globally using pip:pipinstall-Uhyper-systemsAdding as a dependency to your projectAdd torequirements.txtfor pip:echo"hyper-systems==1.4.0">>requirements.txtConsider usingvenv, if you want to have an isolated environment for your project with pip.Alternatively, install with poetry:poetryadd"hyper-systems==1.4.0"Installing the latest development version of the package globally$pipinstall-Ugit+https://github.com/hyper-systems/hyper-python-sdk.git@masterUsing this repo for developmentThis repo usespoetry(please check thedocs) for development and building. It is currentlu set up to create a.venvdirectory in the root of this project on install.Installing the environment:$poetryinstallShell usageAfter installing you can use the environment created with poetry, for example to:update the environment:$poetryupdateexecute scripts:$poetryruntests/test_devices.pyVSCodeYou can also use the environment in VSCode by opening one of the python files in this repo and selecting the poetry python interpreter in the bottom left corner (('.venv': poetry)). You then reload the VSCode window (or open and close VSCode) and VSCode should be now using the.venvenvironment created by poetry.
Package: hypertab
HyperTabHyperTab is a hypernetwork-based classifier for small tabular datasets.It's especially efficient when the number of samples is smaller than 500. The smaller the dataset, the larger is the advantage of HyperTab over other algorithms.InstallationpipinstallhypertabUsagefromhypertabimportHyperTabClassifierDEVICE="cuda:0"iftorch.cuda.is_available()else"cpu"clf=HyperTabClassifier(0.5,device=DEVICE,test_nodes=100,epochs=10,hidden_dims=5)clf.fit(X,y)clf.predict(X)PerformanceDatasetXGBoostDNRFHyperTabNodeWisconsin Breast Cancer93.8595.5895.9697.5896.19Connectionist Bench83.5279.0283.5087.0985.61Dermatology96.0597.8097.2197.8297.99Glass94.7446.9697.0298.3644.90Promoter81.8878.9185.9489.0683.75Ionosphere90.6793.4392.4394.5291.03Libras74.3881.5477.4285.2282.72Lymphography85.9485.7487.1983.9083.93Parkinsons86.3574.9686.8495.2780.20Zoo92.8672.6292.6295.2789.05Hill-Valley without noise65.5356.3957.3370.5952.71Hill-Valley with noise58.4556.0655.6667.5651.09OpenML 108660.6133.3351.2476.6068.39Heart79.1782.6281.1083.3382.38Mean rank3.503.783.071.353.29
Package: hypertag-lang
Hypertagis a modern language for front-end development that allows
writing markup documents in a way similar to writing Python scripts,
whereindentationdetermines relationships between nested elements
and removes the need for explicit closing tags. Hypertag provides:Advanced control of rendering process with nativecontrol blocks(if,for,while,try).High level of modularity thanks to Python-likeimportsand explicitcontextspecification.Unprecedented support for code reuse with nativecustom tags.NativeDOMrepresentation andDOM manipulationduring rendering.Embeddedcompound expressions.All Pythonoperatorsto manipulate arbitrary Python objects.Custompipelineoperator (:) for chaining multiple functions asfilters.Expressionqualifiers(!?) to create alternative paths of calculation and handle edge cases easily.Built-in tags forHTML5generation and forgeneralpurposes.IntegratedPython built-ins.IntegratedDjango filters.Django connector.More information:Quick StartLanguage ReferenceSetupInstall:pip install hypertag-lang               # watch out the name, it is "hypertag-lang"Usage:fromhypertagimportHyperHTMLhtml=HyperHTML().render(script)# rendering of a Hypertag `script` to HTMLWhy to use HypertagConcise syntax: inspired by Python, the indentation-based syntax is a lot cleaner,
more readable and maintainable than raw markup; it requires less typing, is less redundant,
and lets you concentrate on coding rather than chasing unmatched opening-closing tags.Code reuseby means of functions/classes is the corner stone of programming,
yet it is missing from HTML; this is fixed now with Hypertag:
programmers can create reusable components in a form ofcustom tags(hypertags),
defined either as Python functions (external tags)
or directly in a document using Hypertag syntax (native tags);
hypertags can be parameterized and may represent complex pieces
of combined: content, style and layout - for a reuse across documents.Fine-grained controlover rendering process is possible with
a range of nativecontrol blocks(for, while, if-elif-else, try-else)
constituting a core part of Hypertag syntax, unlike in templating languages,
where control structures are artificially overlaid on top of another language (HTML).Modularityin Hypertag is modeled after Python's:
every script may import tags and variables from other scripts,
from Python modules, and from the dynamiccontextof script rendering;
scripts and modules are arranged into packages;
with these mechanisms in place, building libraries of reusable components is easy and fun.Applicabilityto different target languages.
Hypertag isnotjust a templating system put on top of HTML.
Hypertag is a full-featured standalone programming language tailored to the generation
of documents of all kinds. By defining new tags, Hypertag can be adapted to produce an arbitrary
document description language.AcknowledgementsHypertag was partially modeled onPython'ssyntax, and
was inspired by indentation-based templating languages:Slim,Plim,Shpaml,Haml.
Package: hyperterm-utils
# hyperterm-utils [![Build Status](https://travis-ci.org/mikeanthonywild/hyperterm-utils.svg?branch=master)](https://travis-ci.org/mikeanthonywild/hyperterm-utils)An open-source laptop with maintainability and sustainability in mind. This repo contains Python build tools and utilities for [Hyperterm](https://github.com/mikeanthonywild/hyperterm-hardware).## Package Contentseeschema- Python API and CLI for Eeschema## Resources[Main Hyperterm project](https://github.com/mikeanthonywild/hyperterm-hardware)[Contributing](CONTRIBUTING.md)[Documentation](https://mikeanthonywild.github.io/hyperterm-utils/)
Package: hyperthought
Modules that encapsulate HyperThought API calls and make
operations like authentication and file transfer (upload
or download) easier to accomplish.DescriptionExample usage:Here is the code needed to upload a file to a HyperThought workspace.fromgetpassimportgetpassimporthyperthoughtashtauth_info=getpass("Enter encoded auth info from your HyperThought profile page: ")auth=ht.auth.Authorization(auth_info)files_api=ht.api.files.FilesAPI(auth)# space_id can be found in the url for the workspace# e.g. https://www.hyperthought.io/workspace/<space_id>/detailspace_id=input("Enter destination project id (in url of project): ")# Create a folder.# Use default (root) path and don't specify any metadata for the folder.# (See method docstring for info on unused parameters.)folder_id=files_api.create_folder(name="Tests",space_id=space_id,)# Get a path for the file.# Paths consist of comma-separated parent folder ids.path=f",{folder_id},"local_file_path=input("Enter path to local file: ")files_api.upload(local_path=local_file_path,space_id=space_id,path=path,)# Look in the HyperThought UI to see the uploaded file.
Package: hyperthought-transfer
hyperthought-transferMulti-threaded engine for transferring files between local computers and HyperThought®.The main purpose of this package is to provide functionality for transferring
files between local systems and HyperThought®.  This will be done via a
multithreaded task queue.  Associated functionality will include transfer
manifest generation, antivirus scanning, and metadata parsing.NoteThis project has been set up using PyScaffold 4.2.1. For details and usage
information on PyScaffold seehttps://pyscaffold.org/.
Package: hypertiling
hypertilingis a high-performance Python library for the generation and visualization of regular hyperbolic lattices embedded in the Poincare disk model. Using highly optimized, efficient algorithms, hyperbolic tilings with millions of vertices can be created in a matter of minutes on a single workstation computer. Facilities including computation of adjacent vertices, dynamic lattice manipulation, refinements, as well as powerful plotting and animation capabilities are provided to support advanced uses of hyperbolic graphs.Installationhypertiling is available in thePyPIpackage index and can be installed using$ pip install hypertilingFor optimal performance, we highly recommand to use hypertiling together withpython-numba, which, if not already present on your system can be installed automatically using the[numba]-suffix, i.e.$ pip install hypertiling[numba]The package can also be locally installed from our publicgit repositoryvia$ git clone https://git.physik.uni-wuerzburg.de/hypertiling/hypertiling
$ pip install .UsageIn Python, import tiling object from thehypertilinglibraryfromhypertilingimportHyperbolicTilingSet parameters, initialize and generate the tilingp=7q=3nlayers=5T=HyperbolicTiling(p,q,nlayers)Further examples are available in ourdocumentationand Jupyter demo notebooks.AuthorsManuel Schrauthmschrauth@physik.uni-wuerzburg.deYanick ThurnFlorian GothJefferson S. E. PortelaDietmar HerdtFelix DuselThis project is developed at:Institute for Theoretical Physics and AstrophysicsUniversity of WuerzburgCitationIf you usehypertiling, we encourage you to cite or reference this work as you would any other scientific research. The package is a result of a huge amount of time and effort invested by the authors. Citing us allows us to measure the impact of the research and encourages others to use the library.Cite us:Manuel Schrauth, Yanick Thurn, Florian Goth, Jefferson S.E. Portela, Dietmar Herdt and Felix Dusel. (2023). Thehypertilingproject. Zenodo.https://doi.org/10.5281/zenodo.7559393ExamplesTilingsThe core functionality of the package is the generation of regular hyperbolic tilings projected onto the Poincare disk. Tilings in the upper row are centered about a cell, in the lower row about a vertex.RefinementsThe hypertiling package allows to perform triangle refinements, such as shown hereApplicationsHyperbolic MagnetSimulation of a Ising-like Boltzmann spin model with anti-ferromagnetic interactions on a hyperbolic (7,3) tiling, quenched at low temperature. The hyperbolic antiferromagnet (left) exhibits geometrical frustration, whereas on a flat lattice (right) an ordered anti-parallel alignment can be observed.Helmholtz EquationSolution of an electrostatic Helmholtz problem on a refined (3,7) tiling, where boundary values have been fixed to either -1 (red) or +1 (blue). One readily recognizes a field value separation according to geodesic arcs in the Poincare disk representation of the hyperbolic plane.Further information and examples can be found in our Jupyter notebooks in /examples subfolder.LicenseEvery part of hypertiling is available under the MIT license.
Package: hypertools
HyperTools is a library for visualizing and manipulating high-dimensional data in Python. It is built on top of matplotlib (for plotting), seaborn (for plot styling), and scikit-learn (for data manipulation).For sample Jupyter notebooks using the package:https://github.com/ContextLab/hypertools-paper-notebooksFor more examples:https://github.com/ContextLab/hypertools/tree/master/examplesSome key features of HyperTools are:Functions for plotting high-dimensional datasets in 2/3D.Static and animated plotsSimple API for customizing plot stylesA set of powerful data manipulation tools including hyperalignment, k-means clustering, normalizing and more.Support for lists of Numpy arrays, Pandas dataframes, String, Geos or mixed lists.