Saravanan666/pypi-org huggingface dataset:
Package: hypnettorch
Hypernetworks for PyTorchThis packagecontains utilities that make it easy to work withhypernetworksinPyTorch.InstallationYou can either install the latest package version viapython3 -m pip install hypnettorchor, you directly install the current sourcespython3 -m pip install git+https://github.com/chrhenning/hypnettorchInstallation for developersIf you actively develop the package, it is easiest to install it indevelopment mode, such that all changes that are done to source files are directly visible when you use the package.Clone the repository to a location of your choicegit clone https://github.com/chrhenning/hypnettorch.gitand move inside the cloned repocd ./hypnettorchNow, you can simplyinstallthe package ineditablemode, which will ensure that you can easily update the package sources (cf.development mode)pip3 install --editable . --userSince the package was installed ineditablemode, you can always update the sources simply by pulling the most recent codegit pullYou canuninstallthe package at any point by runningpython3 setup.py develop -u.UsageThe basic functionalities of the package are quite intuitive and easy to use, e.g.,importtorchfromhypnettorch.mnetsimportMLPfromhypnettorch.hnetsimportHMLPmnet=MLP(n_in=8,n_out=1,no_weights=True)# Create MLP with 8 inputs and 1 output.hnet=HMLP(mnet.param_shapes)# Create hypernetwork for the above MLP.weights=hnet.forward(cond_id=0)# Generate the weights of network `mnet`.inputs=torch.rand(32,8)# Random inputs.mnet.forward(inputs,weights=weights)# Compute predictions using the generated weights.There are severaltutorials. Check out thegetting startedtutorial when working withhypnettorchfor the first time.DocumentationThe documentation can be foundhere.Note for developersThe documentation can be build usingpython3 setup.py build_sphinxand opened via the fileindex.html.CitationWhen using this package in your research project, please consider citing one of our papers for which this package has been developed.@inproceedings{oshg2019hypercl,
title={Continual learning with hypernetworks},
author={Johannes von Oswald and Christian Henning and Jo{\~a}o Sacramento and Benjamin F. Grewe},
booktitle={International Conference on Learning Representations},
year={2020},
url={https://arxiv.org/abs/1906.00695}
}@inproceedings{ehret2020recurrenthypercl,
  title={Continual Learning in Recurrent Neural Networks},
  author={Benjamin Ehret and Christian Henning and Maria R. Cervera and Alexander Meulemans and Johannes von Oswald and Benjamin F. Grewe},
  booktitle={International Conference on Learning Representations},
  year={2021},
  url={https://arxiv.org/abs/2006.12109}
}@inproceedings{posterior:replay:2021:henning:cervera,
title={Posterior Meta-Replay for Continual Learning}, 
      author={Christian Henning and Maria R. Cervera and Francesco D'Angelo and Johannes von Oswald and Regina Traber and Benjamin Ehret and Seijin Kobayashi and Benjamin F. Grewe and João Sacramento},
booktitle={Conference on Neural Information Processing Systems},
year={2021},
url={https://arxiv.org/abs/2103.01133}
}
Package: hypno
HypnoA cross-platform tool/library allowing to inject python code into a running python process.
Based onkmaork/pyinjector.If you are trying to debug a python process, check outkmaork/madbg.InstallationpipinstallhypnoBoth source distributions, manylinux, musslinux, mac and windows wheels are uploaded to pypi for every release.UsageCLIhypno<pid><python_code>APIfromhypnoimportinject_pyinject_py(pid,python_code)ExampleThis example runs a python program that prints its pid, and then attaches to the newly created process and
injects it with another print statement using hypno.python-c"import os, time; print('Hello from', os.getpid()); time.sleep(0.5)"&\hypno$!"import os; print('Hello again from', os.getpid())"SecurityHypno briefly generates a temporary file containing the requested python code.
This file is given 644 permissions by default, which means all users can read it.
To use custom permissions, you can pass thepermissionsargument toinject_py().
Package: hypnobox-django
=============================hypnobox-django=============================.. image:: https://badge.fury.io/py/hypnobox-django.png:target: https://badge.fury.io/py/hypnobox-django.. image:: https://travis-ci.org/fgmacedo/hypnobox-django.png?branch=master:target: https://travis-ci.org/fgmacedo/hypnobox-djangoIntegrate your site with Hypnobox chat service.Documentation-------------The full documentation is at https://hypnobox-django.readthedocs.org.Quickstart----------Install hypnobox-django::pip install hypnobox-djangoInclude it on `INSTALLED_APPS`::'hypnobox',And in your routes (`urls.py`)::url(r'^leads/', include('hypnobox.urls', namespace='hypnobox')),Then use it in a template:.. code-block:: django{% load hypnobox_tags  %}{% new_lead "your-product-code" "your-media-name" %}It will render a link to a :ref:`LeadForm`, and on submiting this form, itwill persist a lead and redirect the user to Hypnobox chat.Features--------* TODORunning Tests--------------Does the code actually work?::source <YOURVIRTUALENV>/bin/activate(myenv) $ pip install -r requirements_test.txt(myenv) $ python runtests.pyHistory-------0.1.0 (2016-09-08)++++++++++++++++++* First release on PyPI.
Package: hypnotic-bets-review
Hey there,I'm absolutely delighted that you're going to get to see this.Hypnotic Bets has just gone live and it's helping people to make THOUSANDS OF POUNDSevery single week on the horses!Chris Haydock was a regular tipster - who made a nice living from the nags...Until a chance hypnosis session altered his mindset and allowed him to start eliminating risky bets from his selections!Since then he's been making over 250k per year and he's now giving you the chance to copy his daily tips.>> Get The Tips HERE <<And since Chris is somebody I've known for a while, he's giving my subscribers the chance to get on in this before all the spots are taken.This will NOT be around for long...So I suggest you get in there right away while your place is guaranteed.>> Secure Your Place HERE <<You can thank me later!Best regards,# hypnotic bets review
```bash
pip3 hypnotic bets review
Package: hypo
WIPHypoHyis a LISP dialect running on a
Python virtual machine.Hypoallows you to build small
applications from Hy source files. Similar to Python’szipapp,Hypocreates executable archives. Since the Hy source files will be
compiled into .pyc files, the executable archive will run faster than
on interpreter.RequirementsPython >= (2.6, 3.5)Hy >= 0.12.1Installation$ pip install hypoUsage$ hypo --help
usage: hypo [options] <targets>

options:
  -o [file]  output name
  --version  show program's version number and exit
  --help     show this message and exitExampleYou can build these source files as follows:$ hypo -o app main.hy iota.hyAnd you can execute the application as follows:$ ./app
(0L 1L 2L 3L 4L 5L 6L 7L 8L 9L)or$ python app
(0L 1L 2L 3L 4L 5L 6L 7L 8L 9L)Source filesiota.hy(defniota[m&optional[n0][step1]](if(>=nm)None(consn(iotam(+nstep)step))))main.hy(import[iota[iota]])(defmain[&restargs](print(iota10)))LicenseDistributed underMIT
License.AuthorKojiro TANI(kojiro0531@gmail.com)
Package: hypofuzz
HypoFuzzAdaptive fuzzing ofHypothesistests.Property-based approaches help you to write better tests which find more bugs,
but don't have great ways to exchange much more CPU time for more bugs.
The goal of this project is to bring togther the best parts of fuzzing and PBT.MotivationYou canrun a traditional fuzzerlike AFL on Hypothesis tests to get basic coverage guidance.  This works OK, but there's
a lot of performance overhead.  Installing, configuring, and connecting all the parts is
a pain, and because it assumes one fuzz target per core you probably can't scale up far
enough to fuzz your whole test suite.Alternatively, you can just run Hypothesis with a largemax_examplessetting.
This also works pretty well, but doesn't get the benefits of coverage guidance and
you have to guess how long it'll take to run the tests - each gets the same budget.HypoFuzz solves all of these problems, and more!FeaturesInterleave execution of many test functionsPrioritise functions where we expect to make progressCoverage-guided exploration of your system-under-testSeamless python-native and CLI integrations (replaces thepytestcommand)Web-based time-travel debugging withPyTrace(automatic if youpip install hypofuzz[pytrace])Read more about HypoFuzz athttps://hypofuzz.com/docs/, includingthe changelog.
Package: hypoinvpy
HypoInvPyA Python interface for HypoInverse earthquake relocation softwareThis package is not intended to show documentation of how to usehypoinverse. Instead, we focus on buiding an user-friendly Python interface to runhypoinverse. For detailed documentation ofhypoinverse, please read the documentation for hypoinverse inhyp1.40/doc/hyp1.40.pdf. The documentation for this interface package is indoc/HypoInvPy_manual.pdf.Credit noteThe codes and workflow in this package are modified and simplified from Hypo-Interface-Py (https://github.com/YijianZhou/Hypo-Interface-Py). The hypoinverse version is 1.4 and can be downloaded from USGS (https://www.usgs.gov/software/hypoinverse-earthquake-location).InstallationCreate and activate a Python virtual environmenthypoinv. This is optional but recommended. This will help isolate the computational needs from other packages. This will also help avoid version incompatibility in case new packages for some codes are updated in thebaseconda environment. However, sinceHypoInvPydoesn't currently need complicated packages, running under thebaseenvironment may just work fine.$ conda create -n hypoinv -c conda-forge jupyter numpy scipy pandas python cartopy obspy mpi4pyThen, activate the environment with:$ conda activate hypoinvClone the github repository, in terminal under the desired directory:$ git clone https://github.com/xtyangpsp/HypoInvPy.gitcdto the repository folder in terminal and install the package with the parameters insetup.py.$ pip install .Create jupyter notebook kernel with the environment (after activating the environment).$ pip install --user ipykernel
$ python -m ipykernel install --user --name=hypoinvRun the hypoinverse example:Make sure hypo1.40 has been installed on your computer. Download the version from the USGS website (https://www.usgs.gov/software/hypoinverse-earthquake-location). For your convinience, a copy of the hyp1.40 codes is available under folderhyp1.40.In terminal under theexampledirectory, run the jupyter notebookHypoInvPy_run_example.ipynbThe output directory includes the resultant earthquake catalogs.Upcoming changes:Add visualization functionalities, e.g., earthquake locations and depth distribution and temporal sequence, etc.
Package: hypothepy
HypothepyA lightweight Python API forHypothes.isFree software: MIT licenseDocumentation:https://hypothepy.readthedocs.ioCheck the official hypothes.is documentation:https://h.readthedocs.io/en/latesthttps://h.readthedocs.io/en/latest/api-referenceFeaturesLight Python interface for all the REST endpoints available.API parameters are simple native python typesAPI calls just return arequests.Responseobjectprovides handy helpersPython 3.6+Onlyversion 1 (stable)implemented (for the moment)OnlyAPIKey Authenticationimplemented (for the moment)Command line interface (cooming soon)History0.2.0 (2019-08-28)First release on PyPI.
Package: hypothesis
Hypothesis is an advanced testing library for Python. It lets you write tests which
are parametrized by a source of examples, and then generates simple and comprehensible
examples that make your tests fail. This lets you find more bugs in your code with less
work.e.g.@given(st.lists(st.floats(allow_nan=False,allow_infinity=False),min_size=1))deftest_mean(xs):assertmin(xs)<=mean(xs)<=max(xs)Falsifying example: test_mean(
  xs=[1.7976321109618856e+308, 6.102390043022755e+303]
)Hypothesis is extremely practical and advances the state of the art of
unit testing by some way. It’s easy to use, stable, and powerful. If
you’re not using Hypothesis to test your project then you’re missing out.Quick Start/InstallationIf you just want to get started:pip install hypothesisLinks of interestThe main Hypothesis site is athypothesis.works, and contains a lot
of good introductory and explanatory material.Extensive documentation and examples of usage areavailable at readthedocs.If you want to talk to people about using Hypothesis,we have both an IRC channel
and a mailing list.If you want to receive occasional updates about Hypothesis, including useful tips and tricks, there’s aTinyLetter mailing list to sign up for them.If you want to contribute to Hypothesis,instructions are here.If you want to hear from people who are already using Hypothesis, some of themhave written
about it.If you want to create a downstream package of Hypothesis, please readthese guidelines for packagers.
Package: hypothesis-010
hypothesis-010AHypothesisstrategy for generating data
that matches some010 editorbinary template.This includes over170 binary file formats built in,
andmany more from the community.Here's the PyPI pageandthe GitHub repo.APIhypothesis-010is in the planning stages, inspired byFormatFuzzerand the wide variety of
useful features already integrated into Hypothesis.Check back soon to see what progress we've made, orget in touchto let me know you're interested - this is a long way from the top of my todo list.Supported versionshypothesis-010requires Python 3.6 or later.
In general, 0.x versions will require very recent versions of all dependencies
because I don't want to deal with compatibility workarounds.You cansponsor meto get priority
support, roadmap input, and prioritized feature development.ChangelogPatch notescan be found inCHANGELOG.md.
Package: hypothesis-api
HypothesisA python wrapper for the Hypothesis APICreate an annotation using a TextQuoteSelectorh = hypothesis.Hypothesis(username=USER, token=TOKEN)  # your h username and api token (from https://hypothes.is/account/developer)

url = 'url of web page to annotate'
exact = 'selected text (i.e. the quote)'
prefix = '30 chars preceding the quote'
suffix = '30 chars following the quote'
title = 'title of the web page'
tags = ["tag1", "tag2"]
text = "body of annotation, can include [markup](http://example.com)"
   
payload = {
    "uri": url,
    "target": 
        [{
            "source": [url],
            "selector": 
                [{
                    "type": "TextQuoteSelector", 
                    "prefix": prefix,
                    "exact": exact,
                    "suffix": suffix
                    }
                 ]
        }], 
    "tags": tags,
    "text": text,
     "document": {
         "title": [title]
     },
     "permissions": h.permissions,
     "group": h.group
  }

r = h.post_annotation(payload)
print r.status_code
Package: hypothesis-array-api
Hypothesis strategies for Array API librariesNote:hypothesis-array-apiuses private APIs from Hypothesis
and so should be considered unstable.InstallYou can get the strategies from PyPI.pipinstallhypothesis-array-apiTo install from source,get Poetryand thenpoetry installinside the repository.
Usingpoetry shellis a good idea for development,
where you can usepytestto run the full test suite
(note there a lot of expected warnings I need to declutter.)Quickstartfromnumpyimportarray_apiasxpfromhypothesisimportgivenfromhypothesis_arrayimportget_strategies_namespacexps=get_strategies_namespace(xp)@given(xps.arrays(dtype=xps.scalar_strategies(),shape=xps.array_shapes()))defyour_test(array):...Contributors@honnocreated these strategies
with input from@mattip,@asmeurer,@rgommersand other great folk from@Quansight-Labs.Inspiration was taken from theNumPy strategiesthat Hypothesis ships with athypothesis.extra.numpy.
Thanks to the Hypothesis contributors who helped shape it, including:@Zac-HD,@rsokl,@DRMacIver,@takluyver,@rdturnermtl,@kprzybyla,@sobolevn,@kir0ul,@lmount,@jdufresne,@gsnsw-felixsand@alexwlchan.
Package: hypothesis-asn1
hypothesis-asn1AHypothesisstrategy for generating data
that matches someASN.1 format.Here's the PyPI pageandthe GitHub repo.APIhypothesis-asn1is in the planning stages, so there is no public API yet.Supported versionshypothesis-asn1requires Python 3.6 or later.
In general, 0.x versions will require very recent versions of all dependencies
because I don't want to deal with compatibility workarounds.ChangelogPatch notescan be found inCHANGELOG.md.
Package: hypothesis-bio
Hypothesis-bioThis module provides aHypothesisstrategy for generating biological data formats.
This can be used to efficiently and thoroughly test your code.InstallationThis module can be installed viapip:pip install hypothesis-bioDevelopmentTests can be executed using tox:tox -e py37runs all tests in a Python 3.7 environment.There are alsopre-commitfiles available, so you can runpre-commit installto add them to your repo.
(These are enforced by CI)See alsoThis module is based onHypothesis-networkx,hypothesis-csvandhypothesis-jsonschema.
Package: hypothesis-csv
hypothesis-csvis an extension to thehypothesisframework. The goal of this framework is to offer a flexible tool
to perform generative-testing/property-based testing for software that accepts CSV files as an input.Descriptionhypothesis-csvis designed with two main use cases in mind:test software that accepts a wide spectrum of CSV formats and doesn’t make assumptions on the content (i.e. CSV parsers)test software that accepts very specific CSV formats and makes assumption on the content, types and header fields.It provides two strategies,data_rowsandcsv, to pursue this goal, both contained in thestrategiesmodule.
Please refer to their documentation and the examples for more details.ExamplesGenerate arbitrary, non-empty CSVfromhypothesis_csv.strategiesimportcsv@given(csv=csv())deftest_my_csv_parse(csv):parsed_csv=my_csv_parser(csv)assert...Generate CSV of a given size (5 columns x 20 rows)fromhypothesis_csv.strategiesimportcsv@given(csv=csv(lines=20,header=5))deftest_my_csv_parse(csv):parsed_csv=my_csv_parser(csv)assertparsed_csv.num_columns==5assertparsed_csv.num_rows==20Generate CSV with a headerfromhypothesis_csv.strategiesimportcsv@given(csv=csv(header=["timestamp","val_1","val_2"]))deftest_my_csv_parse(csv):parsed_csv=my_csv_parser(csv)assertparsed_csv.num_columns==3Generate CSV with columns of a given typefromhypothesis_csv.strategiesimportcsv@given(csv=csv(columns=[text(),int(),float()]))deftest_my_csv_parse(csv):parsed_csv=my_csv_parser(csv)assertparsed_csv.num_columns==3Generate CSV with a given dialectfromhypothesis_csv.strategiesimportcsv@given(csv=csv(columns=[text(),int(),float()],dialect="excel-tab"))deftest_my_csv_parse(csv):...Generate CSV with drawns dialectsfromhypothesis_csv.strategiesimportcsv@given(csv=csv(columns=[text(),int(),float()],dialect=None))deftest_my_csv_parse(csv):...
Package: hypothesis-drf
[Hypothesis](https://github.com/HypothesisWorks/hypothesis-python) strategy for[Django REST framework](http://www.django-rest-framework.org/) serializers.Generate data that is valid according to a DRF serializer### Known issues* Only tested with python3.6* `URLField` can be slow when generating the first example* `*RelatedField` gets first object in queryset, not random* Not all fields are supported, known non-working:- FileField- FilePathField- ImageField- ModelField### Example```bashpip install hypothesis-drf``````pythonfrom hypothesis_drf import from_serializer, from_fieldfrom rest_framework import serializersclass ExampleSerializer(serializers.Serializer):name = serializers.CharField(min_length=3, max_length=8)amount = serializers.IntegerField(min_value=200, max_value=500)from_serializer(ExampleSerializer).example()# {'amount': 391, 'name': '\U00053a6b&\U00030fee$.'}from_field(serializers.FloatField(min_value=-10, max_value=22)).example()# -8.499125311228873```For HyperLinkedRelatedField (and variants) you must pass an instantiated serializer asthey require access to the request via context:```pythonfrom hypothesis_drf import from_serializerclass RelatedExample(serializers.ModelSerializer):class Meta:model = SourceModelfields = ('target', )target = HyperLinkedRelatedField(queryset=TargetModel.objects.all())from_serializer(RelatedExample(context={'request': request})).example()# {'target': 'http://example.com/something/'}```### Custom fieldsProvide `hypothesis_strategy` on the field:```pythonfrom rest_framework import fieldsfrom hypothesis import strategies as stclass MyField(fields.Field):hypothesis_strategy = st.booleans()# ...```
Package: hypothesis-grammar
Hypothesis-Grammar(pre-alpha... the stuff I've tried all works, not well tested yet though)What is it?Hypothesis-Grammar is a "reverse parser" - given a grammar it will generate examples of that grammar.It is implemented as aHypothesisstrategy.(If you are looking to generate text from a grammar for purposes other than testing with Hypothesis then this lib can still be useful, but I stongly recommend looking at thetools provided with NLTKinstead.)UsageSo, how does this look?First you need a grammar. Our grammar format is based on that used by theLark parserlibrary.  You can see our grammar-parsing grammarhere. More details of our grammar formatbelow.Here is an example of using Hypothesis-Grammar:fromhypothesis_grammarimportstrategy_from_grammarst=strategy_from_grammar(grammar="""DET: "the" | "a"N: "man" | "park" | "dog"P: "in" | "with"s: np vpnp: DET Npp: P npvp: "slept" | "saw" np | "walked" pp""",start="s",)st.example()# ['a', 'dog', 'saw', 'the', 'man']st.example()# ['a', 'park', 'saw', 'a', 'man']st.example()# ['the', 'man', 'slept']or as a test...fromhypothesisimportgivenfromhypothesis_grammarimportstrategy_from_grammar@given(strategy_from_grammar(grammar="""DET: "the" | "a"N: "man" | "park" | "dog"P: "in" | "with"s: np vpnp: DET Npp: P npvp: "slept" | "saw" np | "walked" pp""",start="s",))deftest_grammar(example):nouns={"man","park","dog"}assertany(nouninexamplefornouninnouns)The grammar is taken from an example in the NLTK docs and converted into our "simplified Lark" format.start="s"tells the parser that the start rule iss.As you can see, we have produced a Hypothesis strategy which is able to generate examples which match the grammar (in this case, short sentences which sometimes makes sense).The output will always be a flat list of token strings. If you want a sentence you can just" ".join(example).But the grammar doesn't have to describe text, it might represent a sequence of actions for example. In that case you might want to convert your result tokens into object instances, which could be done via a lookup table.(But if you're generating action sequences for tests then probably you should check out Hypothesis'stateful testingfeatures first)Grammar detailsWhitespace is ignored'Terminals' must be named all-caps (terminals only reference literals, not other rules), e.g.DET'Rules' must be named all-lowercase, e.g.npLHS (name) and RHS are separated by:String literals must be quoted with double-quotes e.g."man"You can also use regex literals, they are delimited with forward-slash, e.g./the[a-z]{0,2}/. Content for the regex token is generated using Hypothesis'from_regexstrategy, withfullmatch=True.Adjacent tokens are concatenated, i.e.DET Nmeans aDETfollowed by aN.|is alternation, so"in" | "with"means one-of"in"or"with"?means optional, i.e."in"?means"in"is expected zero-or-one time.*i.e."in"*means"in"is expected zero-or-many times.+i.e."in"+means"in"is expected one-or-many times.~ <num>means exactly-<num> times.~ <min>..<max>is a range, expected between-<min>-and-<max> times.(and)are for grouping, the group can be quantified using any of the modifiers above.