Saravanan666/pypi-org huggingface dataset:
Package: hamcrest-proto
hamcrest-protoHamcrestmatchers forProtocol Buffersin Python.This is forked fromproto-matcherwhich was no longer receiving updates and which was itself based onMessageDifferencerandEqualsProtogoogletest matcher.APIThis packages provides the following proto-relatedmatchers:equals_protoequals_proto(message:Union[Message,str])Test the argument equals the given protobuf message.approximatelyapproximately(proto_matcher:Matcher[Message],float_margin:Optional[float]=None,float_fraction:Optional[float]=None)Test the argument equals the given protobuf message, while comparing any float field using approximation.ignoring_field_pathsignoring_field_paths(field_paths:Set[Tuple[str]],matcher:_ProtoMatcher)Test the argument equals the given protobuf message, while ignoring those fields specified in the field paths.ignoring_repeated_field_orderingignoring_repeated_field_ordering(proto_matcher:Matcher[Message])Test the argument equals the given protobuf message, ignoring the ordering of any repeated field.partiallypartially(proto_matcher:Matcher[Message])Test the argument partially equals the given protobuf message, i.e. if a field is in the argument but not in the expected message, it's ignored in the comparsion.
Package: hamel
hamelHamel’spython utilities for rapid development.InstallpipinstallhamelHow to use!oai_list_models--ownedopenai--limit15| Name                    | Created Dt   |
|:------------------------|:-------------|
| gpt-4                   | 2023-06-27   |
| gpt-4-0314              | 2023-06-27   |
| gpt-4-0613              | 2023-06-12   |
| gpt-3.5-turbo-0613      | 2023-06-12   |
| gpt-3.5-turbo-16k-0613  | 2023-05-30   |
| gpt-3.5-turbo-16k       | 2023-05-10   |
| tts-1                   | 2023-04-19   |
| gpt-3.5-turbo-0301      | 2023-02-28   |
| gpt-3.5-turbo           | 2023-02-28   |
| whisper-1               | 2023-02-27   |
| text-embedding-ada-002  | 2022-12-16   |
| text-davinci-003        | 2022-11-27   |
| curie-similarity        | 2022-04-28   |
| babbage-search-document | 2022-04-28   |
| ada-code-search-text    | 2022-04-28   |!oai_new_func--helpusage: oai_new_func [-h] [--name NAME] [--description DESCRIPTION] [--url URL]
                    [--email EMAIL]

Generate minimal scaffolding for an OpenAI Plugin.

options:
  -h, --help                 show this help message and exit
  --name NAME                the name of your app for the LLM, ex: `todo`. By
                             default, this is inferred from the name of your git
                             repo.
  --description DESCRIPTION  the description of your application that will be
                             read by the LLM.
  --url URL                  The url of your function endpoint. (default:
                             http://localhost:8000)
  --email EMAIL              The email associated with your app. By default this
                             is inferred by git.!fetch_site--helpusage: fetch_site [-h] [--to_html] url output_dir

Fetch content from the specified URL and save it to the given directory. Saves
the content as a markdown file unless `to_html` is True.

positional arguments:
  url         The site that you want to fetch documents from
  output_dir  The output directory to write documents to,

options:
  -h, --help  show this help message and exit
  --to_html   Write output as HTML instead of markdown. (default: False)
Package: hamel-deck-of-cards
Deck of CardsThis repo uses code fromAllen Downey’sThinkPython2.InstallAfter cloning this repository:pip install -e .There is already a project calleddeck_of_cards on
pypi. This project has no
relation to that. This project is an example of how to create python
packages withnbdev.How to usePlaying cards in python!fromdeck_of_cards.deckimportDeckd=Deck()print(f'Number of playing cards in the deck:{len(d.cards)}')Number of playing cards in the deck: 52card=d.pop_card()print(card)King of SpadesSeethe docsfor more
info.
Package: hamlet
hamlet - CLIhamlet is a tool to manage infrastructure throughout the life of your application. With hamlet you define the functional components of your application along with the context they should be run in. The context includes things like environments, tenants, and policies that can be applied across all of your different applications.
From this information hamlet then creates the infrastructure that will perform the function you have asked for and manages it over the life of your application.This repository contains the CLI for hamlet which acts as the primary interface for hamlet.Supporthamlet is built on a plugin based approach so you can create infrastructure for any provider you want, we provide an API of common processes and tasks for provisioning and describing infrastructure which allows you to build a common language across different infrastructure providersWe also provide official plugins for:Amazon Web Services (AWS) based on CloudFormationMicrosoft Azure based on Azure Resource Managermingrammer Diagrams for generating diagrams of your deployed infrastructureDocsTo read more about hamlet and what it can do head to our docs sitehttps://docs.hamlet.io/InstallationTo run hamlet some extra dependencies are required. Head over to thehamlet install guidefor details installing hamlet
Package: hamlreloader
# HamlReloader
[![Build Status](https://travis-ci.org/petermelias/hamlreloader.png?branch=master)](https://travis-ci.org/petermelias/hamlreloader) [![Coverage Status](https://coveralls.io/repos/petermelias/hamlreloader/badge.png?branch=master)](https://coveralls.io/r/petermelias/hamlreloader?branch=master) [![Downloads](https://pypip.in/d/hamlreloader/badge.png)](https://crate.io/packages/hamlreloader) [![Downloads](https://pypip.in/v/hamlreloader/badge.png)](https://crate.io/packages/hamlreloader)## UsageRun without arguments to read and generate to same directory` hamwatch `Run with arguments for source / target spec.` hamwatch my_haml/ my_html/ `OR -` hamwatch . rendered/ `CLI outputs generated path on change.Boom. That’s it.
Package: hammae
CHANGES1.0.1 (03-08-2019)Fix setup.py so that an install of the package will actually work.1.0.0 (03-08-2019)Initial PyPI release.HamMaeThis package provides a Python 3 ported version of Python 2.7’shammaemodule. It has also been back-ported to work in Python 2.6.In Python 3, the implementation ofrandrange()was changed, so that even
with the same seed you get different sequences in Python 2 and 3. Note that
several high-level functions such asrandint()andchoice()userandrange().In my testing code I heavily rely on stable hammae generator results and it
makes porting code to Python 3 a lot harder, if all those tests have to be
adjusted. This package fixes that.
Package: hammercloud
sh_ Hammercloud## What does it doCurrently still expanding that.  This is just getting stuff added as I think about itCurrently it can:- Log you into nextgen cloud servers (using the uuid or server name)- Just show general information about the cloud server- Setup your `supernova temp <command>` stuff (ddi or username)## Installing```pip install --upgrade hammercloud```## ConfiguringYou need a config file, if for nothing else than your sso### ~/.config/hammercloud/config.yml```yamlhammercloud:user: <user>plugin: rackspacessh_args: -F ~/.ssh/extraconfbastion_key: ~/.ssh/id_rsabastion: <bastion>terminal: itermuse_supernova: Trueshelltype: <pshell/expect>```## Autorun!Autorun scripts can go in two places, if you just want to have one script foreverything, you can drop it in `~/.config/hammercloud/autorun`. Alternatively`~/.config/hammercloud/autorun.d/` is available.  It runs them in order(running sorted() in python against the listdir of the directory.To list out all the scripts so you can see the order they will run, pass--list-scripts.```hc --list-scripts``````[~]$ tail -c +0 ~/.config/hammercloud/autorun.d/*==> /home/gtmanfred/.config/hammercloud/autorun.d/1-terminfo <==export TERM=xterm==> /home/gtmanfred/.config/hammercloud/autorun.d/10-check-ip <==ip addr showip route showip -s link==> /home/gtmanfred/.config/hammercloud/autorun.d/20-heartbleed <==lsof +c 0 -n | awk '/lib(ssl|crypto)/ && /DEL/ && !x[$1]++ {print $1}'```## Setting up supernovaAdd the following to your ~/.supernova file```ini[temp]OS_AUTH_URL=https://identity.api.rackspacecloud.com/v2.0/OS_AUTH_SYSTEM=rackspaceOS_REGION_NAME=USE_KEYRINGNOVA_SERVICE_NAME=cloudServersOpenStackOS_USERNAME=USE_KEYRINGOS_PASSWORD=USE_KEYRINGOS_TENANT_ID=USE_KEYRINGNOVA_RAX_AUTH=1OS_NO_CACHE=1NOVACLIENT_INSECURE=1```## ssh_args for proxyingSetup the below command, and begin the day with `ssh -Nf -F ~/.ssh/extraconf bastion`Then set the ssh_args in `~/.config/hammercloud/config.yml` to `-F ~/.ssh/extraconf`#### ~/.ssh/extraconf```Host bastionProxyCommand noneUser <user>Hostname <bastion>ControlPath ~/.ssh/vts-%r@%h:%pIdentityFile <ssh_key>ControlMaster autoControlPersist 10mHost *ProxyCommand ssh -aY bastion -F ~/.ssh/extraconf -W %h:%pForwardAgent yesForwardX11 noGSSAPIAuthentication noVerifyHostKeyDNS noHashKnownHosts noStrictHostKeyChecking falseTCPKeepAlive yesServerAliveInterval 300````Note: if you do not use something like this, and use Host * in your .ssh/config, you should includethe following above your Host * to make sure the ProxyCommand is empty````Host cbast*ProxyCommand none```
Package: hammerdraw-setup-manager
HammerDraw Setup ManagerSimple one-file module which defines defaults for the HammerDraw Core and HammerDraw plugins.Usage:In yoursetup.py, add the following:# noinspection PyProtectedMemberfromsetuptoolsimport_install_setup_requires_install_setup_requires(dict(setup_requires=['hammerdraw-setup-manager']))fromhammerdraw_setup_managerimportHammerDrawSetupManagerHammerDrawSetupManager('hammerdraw.modules.my_plugin').setup\(url="https://gitlab.com/hammerdraw/my-plugin/module",short_description="An example plugin for hammerdraw",)See also:Extended Setup ToolsHammerDraw Project
Package: hammer-vlsi
Highly Agile Masks Made Effortlessly from RTL (Hammer)This is the master (unstable) development branch.DocumentationThe documentation is found athttps://hammer-vlsi.readthedocs.ioDoc sources are available atdoc/for offline reading.Hammer currently requires Python 3.9+.For a deeper dive into available options and environment configuration:Core Hammer settingsSetup documentationHammer technology library schemaFor CAD tool settings, please see the relevantdefaults.ymlfor those plugins.Hammer is an integral component of UC Berkeley Architecture Research'sChipyard framework.
Useful documentation for how an example block is pushed through the VLSI flow with Hammer in the free ASAP7 and Sky130 PDKs is athttps://chipyard.readthedocs.io/en/latest/VLSI.HistoryThe list of contributors can be found in the Git history of the project, or online athttps://github.com/ucb-bar/hammer/graphs/contributorsThe Hammer project builds upon the legacy of the PLSI project by Palmer Dabbelt, a previous project which aimed to build a portable VLSI flow. The Hammer project is grateful for the feedback and lessons learned which provided valuable insight that ultimately led to the design and software architecture of Hammer as it is now.Below is the list of Hammer publications in reverse chronological order:Hammer: a modular and reusable physical design flow tool (DAC 2022)A Methodology for Reusable Physical Design (ISQED 2020)PLSI: A Portable VLSI Flow (Master's Thesis, 2017)
Package: hammett
Hammett is a fast python test runner that aims to be compatible with the parts
of pytest most people use (unless that conflicts with the goal of being fast).
It also adds some features that can dramatically improve your testing experience
if you adapt more fully to hammett.How much faster is hammett?This will depend on how fast your test suite is.
Hammett isn’t magic, it’s just a runner made by someone who cares about
performance a lot. It aims to have minimal startup overhead and minimal
overhead for each test. I have written some benchmarks for measuring this
overhead which you can find athttps://github.com/boxed/test-benchmarks(TL;DR
if your test suite is < 1s in pytest you will see VAST improvements, if it’s
minutes or hours, not so much).A real world example is running the test suite of tri.declarative:pytest: ~860 mshammett: ~160 msOr iommi:pytest: ~10 shammett: ~8 sBut even if your test suite is big and slow you can still get some big
improvements out of hammett if you often run just one file or one test:In iommi, running-k test_render_attrs_nonepytest: ~1.3 shammett: ~0.6 sAll of this is from a full and clean run. Hammett has features to avoid that!Tests locked to a moduleIn hammett you can optionally name your test filesmodule__tests.py(that’s
two_). This tells hammett that if you changemoduleonly the tests inmodule__tests.pyneeds to be run. You can place those files either in the
tests directory or right next to the module you’re testing.Run just relevant testsHammett keeps track of what modules and what tests have changed and runs only
the tests it needs to. Assuming you lock your tests to a module like above.If hammett gets confused you can delete the.hammett-dbfile and it will
start from scratch.Pytest features that work in hammettpytest.markparametrized testsfixtureswith pytest.raisesSome plugins work, but you have to specify to load them in setup.cfg:[hammett]plugins=pytest_djangoUsageFirst install:pip install hammettThen run hammett:python -m hammettHopefully it will run your entire test suite!Hammett works with some pytest plugins, most notably pytest-django, at least
for some projects. You need to specify what plugins hammett loads manually
in setup.cfg though.Keeping pytest compatibilityIf you want to use the hammett specific feature ofmodule__tests.py-style
test files, you can still keep compatibility with pytest by specifying the
module of your project and the tests file pattern, like this:testpaths=
    tests
    my_project
python_files=
    *__tests.pyAlso keep importing pytest instead of hammett obviously.LicenseBSD
Package: hamming-digital-filters
hamming-digital-filtersDigital filters by R.W.Hamming. Implementation.Seewiki. Feel free toshare your feedback and report issues.Contributions are welcome.ModulesgradientDifferentiation Filtersgradient_nrNonrecursive Differentiation FilterlowpassLow-Pass Filterslowpass_nrNonrecursive Low-Pass Filterlowpass_mtMonotone Low-Pass FilterReferencesDigital Filters by R.W.Hamming,third edition; Dover publications,
INC., Mineola, New York; ISBN 0-486-65088-X
Package: hammock-builder
Hammock is a framework for building ReST APIs mostly declaratively. It includes data modeling, data storage, authentication, authorization, serialization and interface protocols. It aims to dramatically reduce the effort involved in creating CRUD APIs, including integrating the bits that are specific to your application.HighlightsData modelingProject StatusHammock is in the planning and pre-alpha stages. There are high expectations of open source projects these days and that’s a good thing. However, good software does not spring, fully formed from the forehead of a sleep deprived genius. Rather, it is (or should be, in this person’s humble opinion) the result of continuous design and testing. The whole messy business, starting from day one, is on display here as an invitation to get your hands dirty.Track progress here:https://www.pivotaltracker.com/n/projects/1158082Planned Feature OverviewWe want to create a powerful library for developing ReST APIs that supports a lot of use cases. Here is what we think that needs to look like.Declarative APIMost everything is defined declaratively. That includes the data model, endpoints, filters, sorting and authorization.Easily extensibleData storage, authentication, authorization, serializaton and exchange format are strictly decoupled. Extending functionality in one of these areas requires implementing a small, targeted API.Self-documentingBy using one of the hypermedia exchange formats and/or a generated spec.Batteries includedComes with quite a few options:Data storage:MongoDB and SQLAlchemyAuthentication:Basic, HMAC and TokenSerialization:JSON, MessagePack, XMLExchange formats:A custom, minimalist format as well as the Siren and HAL hypermedia formats.HTTP Caching:ETags and If-Modified-SinceAcknowledgementsThis project makes heavy use offalcon. Massive credit to that team. As well,Evewas a big inspiration, philosophically and to a lesser extentflask-mongorest.
Package: hammuon
Basic Data Strcutre AlgorithmsInstallingpipinstallhammuonorpipinstall-egit+https://github.com/mcvarer/algorithms.git#egg=hammuon1. Quick SortQuick Sort is a sorting algorithm, which is commonly used in computer science.
Quick Sort is a divide and conquer algorithm.Usagefromhammuon.data_structure.quick_sortimportquickSortprint(quickSort([8,12,55,-12]))Output[-12,8,12,55]2. Bubble SortBubble sort is a sorting algorithm that compares two adjacent
elements and swaps them until they are not in the intended order.Usagefromhammuon.data_structure.bubble_sortimportbubbleSortprint(bubbleSort([8,12,55,-12]))Output[-12,8,12,55]3. Selection SortSelection sort is a simple sorting algorithm.Usagefromhammuon.data_structure.selection_sortimportselectionSortprint(selectionSort([8,12,55,-12]))Output[-12,8,12,55]
Package: hamnonlineng
Following the formalism described in “Black-box superconducting circuit
quantization”http://arxiv.org/abs/1204.0587we can expandsin(a+b+…+h.c.)orcos(a+b+…+h.c.)or any other nonlinearf(a+b+…+h.c.)in order to
obtain non-linear terms in the Hamiltonian (a, b, and other letters represent
the annihilation operators of various oscillator modes). If we drive some of
the modes classically we can create any non-linear term in the effective
Hamiltonian. This module helps solve the constraint on the frequencies of the
modes (both the requirement that some of the monomials in the expansion are
resonant and that all the other terms in the expansion of the nonlinearity are
off-resonant).
Package: hamolicious-chunky
ChunkyA chunking system for game developmentUsing the libraryInstallationrunpip install hamolicious-chunkyImplementing# import necessary modules from libraryfromchunkyimportWorldasBaseWorld,Chunk,Vec2d# setup libraryBaseWorld.render_dist.set(3,3)# how many chunks to loadChunk.size=Vec2d(300,300)# size of chunks in pixels# override the `generate_chunk()` methodclassWorld(BaseWorld):defgenerate_chunk(self,pos:Vec2d)->Chunk:chunk=Chunk(pos)chunk.objects.append()# add objects the chunk should holdreturnchunk# should always return chunk# create playerplayer_pos=Vec2d(500,500)# instantiate classworld=World(player_pos)whileTrue:# main loopworld.update(player_pos)# update to generate new chunks and update the loaded chunkschunks=world.get_loaded_chunks()# gets the chunks inside the render distancechunks=world.get_active_chunk()# gets the current chunk the player is in
Package: hamolicious-cli-table
Console-TableDisplaying Tables in the consoleHow To Use# Import packagefromcli_tableimportTable,align_data_left,align_data_center,align_data_right# Create some datadata=[['First Name','Last Name','Grade'],['Roy','Trenneman',5],['Maurice','Moss',1],['Jen','Barber',6],['Douglas','Reynholm',9],['Richmond','Avenal',7],]# Create the tabletable=Table(data,alignment=[align_data_left,align_data_left,align_data_right],header_alignment=align_data_center,header=True,)# Sort by specific rowstable.sort_by('Grade')# Freeze the tabletable.freeze()# Print the tableprint(table)Output:| First Name | Last Name | Grade |
| Maurice    | Moss      |     1 |
| Roy        | Trenneman |     5 |
| Jen        | Barber    |     6 |
| Richmond   | Avenal    |     7 |
| Douglas    | Reynholm  |     9 |ArgumentsTable()Creates a table objectArgumentTypeDefault ValueDescriptiondatalist[list[Any]]2D array containing the data to be usedmargin=int1Margin around cells, (how many spaces before and after data)alignment=Function|list[Function]How to align data, either per column  (typelist) or globally (typeFunction)header_alignment=FunctionHow to align headersheader=boolFalseDoes the data contain a header (0th row is the header)add_top=boolFalseAdd a top border around the tableadd_bottom=boolFalseAdd a bottom border around the tableuse_color=boolFalseUsecoloramacolors for the tableheader_color_bg=strcolorama.Back.RESETHeader Background Colorheader_color_fg=strcolorama.Fore.LIGHTBLUE_EXHeader Foreground Colorodd_color_bg=strcolorama.Back.RESETOdd Numbered Cells Background Colorodd_color_fg=strcolorama.Fore.BLUEOdd Numbered Cells Foreground Coloreven_color_bg=strcolorama.Back.RESETEven Numbered Cells Background Coloreven_color_fg=strcolorama.Fore.CYANEven Numbered Cells Foreground ColorTable().is_frozen()Checks if the table needs to be frozen before printingTable().sort_by()Sorts the table by the values of a columnArgumentTypeDefault ValueDescriptioncolumnstr|intWhich column index(int) or name(str) to sort bykey=None|CallableNoneSorting key, takes the entire row, should return a sortable value, bu default, returns the entire cellreverse=boolFalseReverses the sorting algorithm, asc or descTable().update_data()Changes the data that the table hasArgumentTypeDefault ValueDescriptiondatalist[list[Any]]New data to be usedTable().freeze()Compiles the given data into a string for quick displayingTable().display() | print(Table())Prints the table
Package: hamolicious-vector-class
Vector-ClassHad a realisation that I lack a good vector class and been having to rewrite parts of it every now and then, so I wrote a simple Vector Class for 2D and 3D Vectors.To use this class, simply download the vector file and import it into your project, alternatively, copy and paste the code from the vector file and paste it into your own file. This class will work with the most basic version of python, meaning, no need for external libraries :)Documentation hereThings I still want to add:Matrix support
Package: hamopy
[![DOI](https://zenodo.org/badge/11513/srouchier/hamopy.svg)](https://zenodo.org/badge/latestdoi/11513/srouchier/hamopy)Hamopy is a python package for the numerical simulation of one-dimensional heat, air and moisture (HAM) transfer in porous materials. Its principle is the finite-element resolution of the HAM conservation equations. The only requirement to run it is a fairly recent version of SciPy.The original field of application is the hygrothermal modelling of building materials, although the code is not restricted to it.Hamopy makes good use of its open-source nature, and gives users complete control over the simulation process. One can:add new materials and customise the equations defining their properties,account for water flow and storage in both liquid and vapor states,include time-dependent boundary conditions,work with fully coupled hygrothermal transfer, or with thermal transfer only (saves time),easily automate many simulations for sensitivity analyses, evolutionary algorithms and such.The documentation is available here:http://srouchier.github.io/hamopy/Any contribution into improving hamopy is welcome, as to make open-source HAM modelling available and understandable by all.