Saravanan666/pypi-org huggingface dataset:
Package: hypermea-core
hypermea-corePlease note:  although we currently use this toolkit to create production-ready APIs, the toolkit is still under development.  Use at your own risk.  This doc is under a heavy rewrite.  Information here is mostly correct, but there are gaps and it's messy.Docs under construction!IntroductionThe core library is used by the hypermea toolkit.  It is not intended to be used by itself (though if you know what you are doing, you could).When you create an API using hypermea, this library is automatically installed and is available for you to use.Please seehypermeafor the full toolkit and documentation.The core libraryThe core library consists of the following modules.  These are all wired up in your API when you created it using hypermea.  Some parts of the library provide useful functions to API developers.  Others are intended for internal use and will not likely be useful to you directly.Usefulhypermea.core.utilsdetailsget_db() -> pymongo.database.Databaseget_api() -> flask.testing.FlaskClientmake_error_response(message: str, code: int, issues) -> flask.wrappers.Responseurl_join(*parts: str) -> stradditional, but not likely usefulget_my_base_url() -> strget_id_field(collection_name: str) -> strget_resource_id(resource: dict, collection_name: str) -> stris_mongo_running() -> bool (coming soon)echo_message()Note: thelog_setup.pyunderutilsis used to set up logging and has no uses for your APIvalidationDescribe theHypermeaValidator, used to add the following validations and types, as well as inheritable to extend:validationsunique_ignorecaseunique_to_parentunique_to_tenant (coming soon)remote_relation (coming soon)typesiso_dateiso_timeiso_duration(link to Eve doc for more info on extending)loggingbackground explanation, mention the addition to the standard python loggingconfiguresstandard formatting,logging errors to SMTP (HY_SEND_ERROR_EMAILS),logging to folder (HY_LOG_TO_FOLDER) - doco details (timed rotation at midnight, etc.)the TRACE level accessible withLOG.trace()the@tracedecorator (enabled by default, disable by settingHY_TRACE_LOGGINGto disable)reference how to adjust the logging verbosity level in the hypermea docssettings_managerdetails: singleton, pulls from environment variables, overridable with_env.conf, etc. (note no underscores in prefix)create(prefix: str, setting_name: str, default_value: str = None, is_optional: bool = False)set_prefix_description(prefix: str, description: str)has_enabled(setting_name: str) -> booldump(prefix: str = None, callback: Optional[Callable[[str], None]] = None)get(setting_name: str, default_value: str = None)[]Not ones you will likely use directlyaffordancesdetailsgatewaydetailshooksdetailsrenderdetails
Package: hypermemory
HypermemoryMeta-data core functionalities for Hyperactive.This package is a collection of core functionalities for the memory module in Hyperactive. It enables Hyperactive to "remember" previous evaluations, which can save significant computation time. The effect is, that every position in the search-space that has been evaluated once never needs to be evaluated again. The previous calculated score has been stored and can just be looked up instead of recalculating it.
Hypermemory also enables persistent storage of python-objects in the meta-data. This means, that information about the objective-function and python-objects in the search-space can be saved and read via the dill-package.Master status:Code quality:Latest versions:
Package: hypermodern-cookiecutter-example
Hypermodern Cookiecutter ExampleFeaturesTODORequirementsTODOInstallationYou can installHypermodern Cookiecutter ExampleviapipfromPyPI:$pipinstallhypermodern-cookiecutter-exampleUsagePlease see theCommand-line Referencefor details.ContributingContributions are very welcome.
To learn more, see theContributor Guide.LicenseDistributed under the terms of theMIT license,Hypermodern Cookiecutter Exampleis free and open source software.IssuesIf you encounter any problems,
pleasefile an issuealong with a detailed description.CreditsThis project was generated from@cjolowicz'sHypermodern Python Cookiecuttertemplate.
Package: hypermodern-python-cli99
hypermodern-python-cli99https://github.com/cjolowicz/hypermodern-pythonhttps://cjolowicz.github.io/posts/hypermodern-python-01-setup/NOTE:this package does not publish to PyPI due to the package name conflict, the badge shows the original package.Use Poetry to manage Black, Flake8, and the other tools as development dependenciespoetry add --dev \
    black \
    flake8 \
    flake8-bandit \
    flake8-black \
    flake8-bugbear \
    flake8-import-order \
    safetyUse pre-commitpip install --user --upgrade pre-commitUse xdoctest to run documentation exmamplespoetry add --dev xdoctestCreate documenation with Sphinxpoetry add --dev sphinx
Package: hypermodern-python-tuto
hypermodern-python-tutoRepo to follow the Claudio Jolowicz'stutorial about Hypermodern Python.
It follows it untilthis release. After this one, I started adding further tools, deleting some that I consider useless and replacing some others.PackageCICodeTable of contentsOverviewInstallUseTools usedGeneric toolsGeneric Python toolsMulti-purposeSetupTestLintingSecurityFormattingType checkingDocumentationSpecific Python toolsUICommunicationData validationOverviewThe app created is a CLI application that queries a random Wikipedia page and displays its title and summary.Installpipinstallhypermodern-python-tutoUseBasic usageJust run the following command:hypermodern-python-tutoOther optionsLook at thedocumentation.Tools usedGeneric toolsTools that can be used in every development project, no matter if it's a Python project or not.Codecov, to mesure code coverage on repos. I let it in this project since it is already setup, but I don't think I will use it in other projects.git, to manage versions of the source code.GitHub, to host the git repository and automate tasks withGitHub Actions:Release Drafter, to create release templates.pre-commit, to manage pre-commit hooks.Generic Python toolsTools that can be used in every Python project, no matter its content.Multi-purposenox, to run tasks in multiple Python environments (like tests, linting, reformatting, etc.).PyPI, to install and publish Python packages.poetry, to make development and distribution easy (packaging, virtualization, dependencies, launching and publishing).TestPyPI, PyPI but for testing purposes.Setuppyenv, to manage Python versions.Testpytest, a framework to write unit tests. Also used to run doctests.pytest-cov, to mesure the code coverage (degree to which the source code of a program is executed while running its test suite).pytest-mock, to use theunittestmocking in the pytest way.LintingRuff, an extremely fast linter that support of all main linter rules.SecurityBandit, to find security issues (used inside linting withflake8-bandit).Safety, to check if some packages are insecure.Formattingblack, to format the code.isort, to sort imports.Type checkingmypy, the classic type checker.DocumentationRead the Docs, to host the documentation.Sphinx, the documentation tool used by the official Python documentation, with:autodoc, Sphinx official plugin to generate API documentation from the docstrings.napoleon, Sphinx official plugin to allow compatibility with Google-style docstrings.sphinx-autodoc-typehints, Sphinx plugin to detect type hints in generated documentation.Specific Python toolsTools to match specific needs of the projet.UIclick, to create CLI applications.Communicationrequests, to make HTTP requests.Data validationmarshmallow, to serialize, deserialize and validate data.I usedmarshmallowto follow the tutorial, butpydanticis more known, and I find it easier to use.
Package: hypermodern-screening
Thehypermodern-screeningpackage provides tools for efficient global sensitivity analyses based on elementary effects. Its unique feature is the option to compute these effects for models with correlated input parameters. The underlying conceptual approach is developed by Stenzel (2020). The fundamental idea comes from Ge and Menendez (2017). It is the combination of inverse transform sampling with an intelligent juggling of parameter positions in the input vector to create different dependency hierarchies. The package does also include a variety of sampling methods.The namehypermodern-screeningis inspired by the brilliant series ofblogarticles about cutting-edge tools for python development by Claudio Jolowicz in 2020. He calls his guide “Hypermodern Python”*. Its corner stones arepoetryfor packaging and dependency management andnoxfor automated testing. Another recommendation is rigorous typing. The repository framework widely follows the blog series.Read the documentationhereand installhypermodern-screeningfrom PyPI with$pipinstallhypermodern_screening**ReferencesStenzel, T. (2020):Uncertainty Quantification for an Eckstein-Keane-Wolpin model with
correlated input parameters.Master’s thesis, University of Bonn.Ge, Q. and Menendez, M. (2017).Extending Morris method for qualitative global sensitivity
analysis of models with dependent inputs.Reliability Engineering & System Safety 100(162),
28-39.*: Claudio, in turn, was inspired by the chess book “Die hypermoderne Schachpartie” (1925) by Savielly Tartakower.**: The image is a detail from the photogravureParis by nightby Albert Robida, 1883 (viaOld Book Illustrations).
Package: hypernetx
The HyperNetX library provides classes and methods for the analysis
and visualization of complex network data modeled as hypergraphs.
The library generalizes traditional graph metrics.HypernetX was developed by the Pacific Northwest National Laboratory for the
Hypernets project as part of its High Performance Data Analytics (HPDA) program.
PNNL is operated by Battelle Memorial Institute under Contract DE-ACO5-76RL01830.Principal Developer and Designer: Brenda PraggastisDevelopment Team: Audun Myers, Mark BonicilloVisualization: Dustin Arendt, Ji Young YunPrincipal Investigator: Cliff JoslynProgram Manager: Brian KritzsteinPrincipal Contributors (Design, Theory, Code): Sinan Aksoy, Dustin Arendt, Mark Bonicillo, Helen Jenne, Cliff Joslyn, Nicholas Landry, Audun Myers, Christopher Potvin, Brenda Praggastis, Emilie Purvine, Greg Roek, Mirah Shi, Francois Theberge, Ji Young YunThe code in this repository is intended to support researchers modeling data
as hypergraphs. We have a growing community of users and contributors.
Documentation is available at:https://pnnl.github.io/HyperNetXFor questions and comments contact the developers directly at:hypernetx@pnnl.govNew Features in Version 2.0HNX 2.0 now accepts metadata as core attributes of the edges and nodes of a
hypergraph. While the library continues to accept lists, dictionaries and
dataframes as basic inputs for hypergraph constructions, both cell
properties and edge and node properties can now be easily added for
retrieval as object attributes.The core library has been rebuilt to take advantage of the flexibility and speed of Pandas Dataframes.
Dataframes offer the ability to store and easily access hypergraph metadata. Metadata can be used for filtering objects, and characterize their
distributions by their attributes.Version 2.0 is not backwards compatible. Objects constructed using version
1.x can be imported from their incidence dictionaries.What’s NewThe Hypergraph constructor now accepts nested dictionaries with incidence cell properties, pandas.DataFrames, and 2-column Numpy arrays.Additional constructors accept incidence matrices and incidence dataframes.Hypergraph constructors accept cell, edge, and node metadata.Metadata available as attributes on the cells, edges, and nodes.User-defined cell weights and default weights available to incidence matrix.Meta data persists with restrictions and removals.Meta data persists onto s-linegraphs as node attributes of Networkx graphs.New hnxwidget available usingpip install hnxwidget.What’s ChangedThestaticanddynamicdistinctions no longer exist. All hypergraphs use the same underlying data structure, supported by Pandas dataFrames. All hypergraphs maintain astate_dictto avoid repeating computations.Methods for adding nodes and hyperedges are currently not supported.Thenwhyoptimizations are no longer supported.Entity and EntitySet classes are being moved to the background. The Hypergraph constructor does not accept either.
Package: hypernode-api-python
Hypernode API Python ClientPlease note: this project is still in its early stages and the API may be subject to change.Installationgitclonehttps://github.com/byteinternet/hypernode-api-python.gitcdhypernode-api-python
python3-mvenvvenv
.venv/bin/activate
pipinstall-rrequirements/development.txtUsageAcquiring an API tokenEach Hypernode has an API token associated with it, you can use that to talk to the API directly. You can find the token in/etc/hypernode/hypernode_api_token. For API tokens with special permissions please contactsupport@hypernode.com. Not all functionality in the API is currently generally available but if you'd like to start automating and have an interesting use-case we'd love to hear from you.Installing the library in your projectFirst make sure your project has the library installed:pipinstall-egit+https://github.com/byteinternet/hypernode-api-python.git@master#egg=hypernode_api_pythonOf course you might want to put that in arequirements.txtfile in your project instead of installing it manually.Alternatively, you can also install thehypernode-api-python library from PyPI:$ python3 -m venv venv
$ . venv/bin/activate
$ pip install hypernode-api-python
$ pip freeze | grep hypernode-api-python
hypernode-api-python==0.0.6Performing API callsThen to use the API client you can test out an example request in your Python repl:fromhypernode_api_python.clientimportHypernodeAPIPythonclient=HypernodeAPIPython(token='yoursecrettoken')response=client.get_app_flavor('yourhypernodeappname')response.json(){'name':'2CPU/8GB/60GB (Falcon S 202202)','redis_size':'1024'}Using the Hypernode-API you can automate all kinds of cool things like configuring settings:client.set_app_setting('yourhypernodeappname','php_version','8.1').json(){'name':'yourhypernodeappname','type':'persistent','php_version':'8.1',...}To even performing acts of cloud automation, like scaling to the first next larger plan:client.xgrade('yourhypernodeappname',data={'product':client.get_next_best_plan_for_app_or_404('yourhypernodeappname').json()['code']})DevelopmentTo run the unit tests you can usetox:tox-rRelated projectsThe officialHypernode API PHP ClientThe officialHypernode DeploytoolThe officialHypernode Dockerimage
Package: hypernova
# hypernova-python [![Build Status](https://travis-ci.org/ornj/hypernova-python.svg?branch=master)](https://travis-ci.org/ornj/hypernova-python)> A Python client for the Hypernova service## Getting StartedInstall the python client from pypi```shpip install hypernova-python```Once you have the client installed and an instance of the Hypernova service running, you can making requests is easy.### Example```pythonimport hypernovarenderer = hypernova.Renderer('http://localhost')html = renderer.render({'MyComponent.js': {'name': 'Foo'}})```## ConfigurationYou can pass configuration options to `Renderer` at initialization.* `url`: The address of the Hypernova service is listening, including port if necessary* `plugins`: A list of plugins to use* `timeout`: Number of seconds to wait for a response from the Hypernova service* `headers`: Dictionary of HTTP headers to override the default. You will want to include `'Content-Type': 'application/json'`## PluginsYou can implement custom events and alter requests through the [Plugin Lifecycle](https://github.com/airbnb/hypernova-node/blob/master/README.md#plugin-lifecycle-api). All lifecycle methods are optional.### Example```pythonimport hypernovaimport randomclass MyPlugin(object):def prepare_request(self, current_jobs, original_jobs):job = current_jobs.get('MyComponent.js')job.update({'random_int_for_reasons': random.randint(0, 100))return current_jobsrenderer = hypernova.Renderer('http://localhost', [MyPlugin()])```
Package: hypernova-orbit
Hypernova 🌠Re-implementation of theSupernova orbit propagatorin a faster and more accessible package.Hypernova is a fast orbit propagator implemented in C and wrapped for Python, designed for the University of Toronto Aerospace Team's FINCH mission. FINCH orbits in a 550 km Sun-Synchronous orbit, and as such the solvers and physics models used by Hypernova were selected for the best simulation fidelity in a low-Earth orbit.InstallationFrom PyPI (recommended)Hypernova is on PyPI ashypernova-orbit. Install using the following command:pip install hypernova-orbitNote that a C compiler is required on your system in order for the C backend to be built.From GitHubYou can install Hypernova from source as a Python package using the following command:pip install git+https://github.com/spacesys-finch/hypernovaThis will let you get the most cutting-edge builds of Hypernova before they're pushed to PyPI.CompatibilityHypernova usescffito wrap a fast C backend into easier-to-access functions in Python. The C backend does not come pre-compiled, and instead requires a compiler on the system to compile modules at install time. Hypernova is designed to automate this process, and it has been tested on the following operating systems:Windows 10 (x86)Ubuntu 20.04 LTS (x86)MacOS 12 (M1)If you have issues installing Hypernova on your computer,please open an issue!DemosHypernova comes with a few examples which you can run.Basic Orbit and Plotpython -m hypernova.examples.basic_orbit_and_plotThis will generate the following output:Testing SuiteHypernova is equipped with a testing suite to validate its functionality. The way to run the testing suite is to copy the scripts from the/testsfolder into your working path and runpytestfrom your command terminal.
Package: hyperon
OverviewOpenCog Hyperon is a substantially revised, novel version of OpenCog - which is currently at an active
pre-alpha stage of development and experimentation. One of the focuses in the Hyperon design is a successor
to the OpenCog Classic Atomese language with clear semantics supporting meta-language features,
different types of inference, etc. What we have landed on is an "Atomese 2" language called MeTTa (Meta Type Talk).One can run MeTTa script from command line:metta <name>.metta
Package: hyperon-das-atomdb
Hyperon DAS AtomDBPersistence layer for Distributed AtomSpaceInstallationThis package requires:python>= 3.8.5 to run.This package is deployed onPypi. If you want, you can install using the pip commandpip install hyperon-das-atomdbIf you want to run it without installing it by pip, you can follow the following approachWe use thePoetrypackage to manage project dependencies and other things. So, if you have Poetry on your machine, you can run the commands below to prepare your environment1. poetry install2. poetry shell(activate virtual environment)Environment VariablesYou must have the following variables set in your environment with their respective values:DAS_MONGODB_HOSTNAME=172.17.0.2
DAS_MONGODB_PORT=27017
DAS_MONGODB_USERNAME=mongo
DAS_MONGODB_PASSWORD=mongo
DAS_MONGODB_TLS_CA_FILE=global-bundle.pem       [optional]
DAS_REDIS_HOSTNAME=127.0.0.1
DAS_REDIS_PORT=6379
DAS_REDIS_USERNAME=admin                        [optional]
DAS_REDIS_PASSWORD=admin                        [optional]
DAS_USE_REDIS_CLUSTER=false                     [default: true]
DAS_USE_REDIS_SSL=false                         [default: true]Usage1 - Redis and MongoDBYou must have Redis and MongoDB running in your environmentTo initialize the databases you must pass the parameters with the necessary values. Otherwise, default values will be used. See below which parameters it is possible to pass and their respective default values:fromhyperon_das_atomdb.adaptersimportRedisMongoDBredis_mongo_db=RedisMongoDB(mongo_hostname='localhost',mongo_port=27017,mongo_username='mongo',mongo_password='mongo',mongo_tls_ca_file=None,redis_hostname='localhost',redis_port=6379,redis_username=None,redis_password=None,redis_cluster=True,redis_ssl=True,)2 - In Memory DBfromhyperon_das_atomdb.adaptersimportInMemoryDBin_memory_db=InMemoryDB()Pre-Commit SetupBefore pushing your changes, it's recommended to set up pre-commit to run automated tests locally. Run the following command (needs to be done once):pre-commitinstallTestsYou can ran the command below to execute the unittestsmaketest-unitDocumentation ReferencesRepositories documentationRelease NotesDAS AtomDB Releases
Package: hyperoptim
HyperoptimHyperparameter Optimization Using Genetic Algorithm.InstallationOS X , Windows & Linux:pipinstallhyperoptimUsage exampleUse for find best hyperparameterfromhyperoptimimportGASearch,Hparamsimporttensorflowastffromtensorflowimportkeras(img_train,label_train),(img_test,label_test)=keras.datasets.fashion_mnist.load_data()# define hyperparameter spaceht=Hparams()hp_units=ht.Int('units',min_value=32,max_value=512,step=32)hp_learning_rate=ht.Choice('learning_rate',values=[1e-2,1e-3,1e-4])hp_activation=ht.Choice('activation',values=['relu','sigmoid','tanh'])# create the list of hyperparameterparams=[hp_units,hp_learning_rate,hp_activation]# define modelparams=[hp_units,hp_learning_rate,hp_activation]defmodel_builder(params):model=keras.Sequential()model.add(keras.layers.Flatten(input_shape=(28,28)))# here params[0] refer to hp_units and params[2] refer to hp_activationmodel.add(keras.layers.Dense(units=params[0],activation=params[2]))model.add(keras.layers.Dense(10))model.compile(optimizer=keras.optimizers.Adam(learning_rate=params[1]),loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),metrics=['accuracy'])returnmodel# intialize the GASearchtuner=GASearch(model_builder=model_builder,params=params,objective='val_accuracy',weights=(1.0,),max_epochs=10,directory='my_dir',project_name='intro_to_kt')# run the searchtuner.search(img_train,label_train,epochs=2,validation_split=0.2)# Get the optimal hyperparametersbest_hps=tuner.get_best_hyperparameters()[0]# Build the model with the optimal hyperparameters and train it on the data for 50 epochsmodel=tuner.build(best_hps)history=model.fit(img_train,label_train,epochs=2,validation_split=0.2)val_acc_per_epoch=history.history['val_accuracy']best_epoch=val_acc_per_epoch.index(max(val_acc_per_epoch))+1print('Best epoch:%d'%(best_epoch,))eval_result=model.evaluate(img_test,label_test)print("[test loss, test accuracy]:",eval_result)Development setupFor local development setupgitclonehttps://github.com/deepak7376/hyperoptimcdhyperoptim
pipinstall-rrequirements.txtMetaDeepak YadavDistributed under the MIT license. SeeLICENSEfor more information.https://github.com/deepak7376/hypertune/blob/master/LICENSEReferencesNone
Package: hyperopt-prophet
Hyperopt ProphetIntegration of prophet forecasting with hyperopt, mlflowThis implementation is based on theDatabricks AutoMLrepository.SetupQuick Installpython-mpipinstallhyperopt_prophetBuild from sourceClone the repositorygitclonehttps://github.com/Broomva/hyperopt_prophet.gitInstall the packagecdhyperopt_prophet&&makeinstallBuild manuallyAfter cloning, create a virtual environmentcondacreate-nhyperopt_prophetpython=3.9
condaactivatehyperopt_prophetInstall the requirementspipinstall-rrequirements.txtRun the python installationpythonsetup.pyinstallUsageimporthyperopt_prophetAttributionHyperopt Prophet builds upon the hard work of others. Here are the original leveraged repositories:Databricks AutoML