Saravanan666/pypi-org huggingface dataset:
Package: haka-mqtt
Thehaka_mqttpackage is reliable “weapons grade” MQTT client library.
It contains a core mqtt reactor class built with provable reliability,
and reproducibility as its fundamental goals.  A side effect is that the
library turns out to be speedy as well.StatusThe project’s core reactor is stable.  It has been tested on systems
with thousands of distributed nodes in difficult field conditions.  The
QoS=1 datapath is well field tested.  The QoS=0 and QoS=2 are not as
thoroughly field tested.While the core reactor is very well tested the frontends are less
tested.  You should pay attention to notes on the different frontends
regarding their status and use.The haka library is mostly tested on Linux derivatives.  It may work on
other platforms but this has not been tested by the authors and no
definite reports of success have been reported to the authors.InstallationThe haka-mqtt package can be installed frompypi.orgwithpip:pipinstallhaka-mqttUsageA quick example of how the package can be used:# Standard python Packagesimportlogging# 3rd-Party Packagesfromhaka_mqtt.frontends.pollimport(MqttPollClientProperties,BlockingMqttClient)fromhaka_mqtt.reactorimportACTIVE_STATESfrommqtt_codec.packetimportMqttTopicLOG_FMT='%(asctime)s%(name)s%(levelname)s%(message)s'logging.basicConfig(format=LOG_FMT,level=logging.INFO)properties=MqttPollClientProperties()properties.host='test.mosquitto.org'properties.port=1883properties.ssl=FalseTOPIC='haka'c=BlockingMqttClient(properties)c.start()sub_ticket=c.subscribe([MqttTopic(TOPIC,1)])c.on_suback=lambdac,suback:c.publish(TOPIC,'payload',1)c.on_publish=lambdac,publish:c.stop()whilec.stateinACTIVE_STATES:c.poll(5.)Project InfrastructureThe project is coordinated through public infrastructure available at
several places:Releases (pypi)Documentation (readthedocs.io)Bug Tracker (github)Code Repository (github)
Package: hakilo
Hakilo - For splitting a text into sentences, and sentences into words.Hakilo (meaning 'axe' in Esperanto) chops a text into sentences for analysis.Sentences usually end with a period, a question mark, or an exclamation mark,
but not every period indicates the end of a sentence. For example:Mrs. C. Bisset is 1.6 meters tall.The above sentence has four periods, but only the last ends the sentence.If there is an end quote mark or an end bracket after a period, the sentence will include the end mark. For example:The tactical officer said, "Shields are down to 30 percent."The last character of the above sentence is a quote mark.When the program encounters a blank line, or any vertical space, it treats this as the end of a sentence.Lines with a length of 0, and lines without any alphabetic characters, are excluded from output. Thus the line:- 2.7will not be included in the output.RequirementsHakilo was developed and tested on Python 3.7 .LinksGithub:https://github.com/Indrikoterio/hakilo-pythonPyPi:https://pypi.org/project/hakilo/1.1.1/InstallationTry this:$ python3 -m pip install hakiloUsageImportingimport hakiloread_fileThis utility function reads in the entire file as a UTF-8 string.the_text = hakilo.read_file("frankenstein.txt")split_textThis function splits the text and returns a list of sentences.sentences = hakilo.split_text(the_text)split_sentenceThis function splits the sentence into words and punctuation.words = hakilo.split_sentence("You can do better.")DeveloperHakilo was developed by Cleve (Klivo) Lendon.ContactTo contact the developer, send email toindriko@yahoo.com. Preferred languages
are English and Esperanto. Comments, suggestions and criticism are welcomed.HistoryFirst release, October 2020.Version 1.1.0 - Added split_sentence() - October 2020.Version 1.1.1 - Fix bug in split_sentence() - October 2020.LicenseHakilo is free software. It is distributed free of charge, without conditions, and without guarantees. You may use, modify and distribute it as you wish. There is no need to ask for permission. If you use Hakilo's code in your own project, and publish it, I request only that you acknowledge the source.
Package: hakka
============hakka-py============.. image:: https://img.shields.io/pypi/v/hakka.svg:target: https://pypi.python.org/pypi/hakka.. image:: https://img.shields.io/travis/Himenon/hakka-py.svg:target: https://travis-ci.org/Himenon/hakka-py.. image:: https://readthedocs.org/projects/hakka-py/badge/?version=latest:target: https://hakka-py.readthedocs.io/en/latest/?badge=latest:alt: Documentation Status.. image:: https:/  /pyup.io/repos/github/Himenon/hakka-py/shield.svg:target: https://pyup.io/repos/github/Himenon/hakka-py/:alt: UpdatesSmall Task Queue* Free software: MIT license* Documentation: <https://hakka.readthedocs.io>.Usage=====.. code-block:: bash$ pip install hakka**Worker**.. code-block:: pythonfrom hakka import Hakkaapp = Hakka()@app.watch('hello:msg')def hello_msg(name=None, msg=None, **kwargs):print("Hello {name}!, {msg}".format(name=name, msg=msg))app.listen('localhost', 6379, 0, debug=True)**Sender**.. code-block:: pythonfrom hakka import HakkaRedisClientif __name__ == '__main__':client = HakkaRedisClient()message = {"name": "hakka","reading": "books"}for i in range(10):message.update({"msg": "Hello World x {}!".format(i),})client.set_value('hello:msg', message).. code-block:: bash$ redis-cli lpush hello:msg '{"name": "yourname", "msg": "Congratulation!"}'How to Develop==============Using: Docker, docker-compose.. code-block:: bash$ docker-compose up# start pytest-watch=======History=======0.1.0 (2018-02-23)------------------* First release on PyPI.
Package: hako
Hako: Command Line Cloud StorageHako is a command line cloud storage client, intefacing with the Hako server backend.InstallationTo install the Hako client, usepip install hakoUsageUsing the client requires logging in. To login, usehako login. This will prompt you for a username and password, and will
store an authentication token at~/.hakorc.To list the files available in your cloud storage, runhako ls.To upload a file, usehako upload <filename>. Currently, filenames in the server must be unique. Two options can be added:--encryptand--make_public. Public files are accessible to any user through the generated link, while encrypted files will require this CLI to download (along with a password entered by the user). Files are encrypted end to end with SHA256 encryption.To share a file, usehako share <filename>. This will generate a link that can be used to share the file over a standard web browser, or using wget from the command line. To delete this link (and prevent further downloads), usehako unshare <filename>.To remove a file, usehako rm <filename>.
Package: hakoniwa
箱庭 (Hakoniwa)"Hakoniwa" which is a miniature garden in Japanese is a simulation framework letting LLM based entities play around inside. This framework aims to provide the way to experiment how the LLM behaves in the specific domain defined as a simple state machine which has states and actions respectively. The framework is designed to be able to be used for the following purposes:To experiment how the LLM behaves in the specific enviroment.To collect the behavior data resembling the human behavior in the real world.UsageDefine the state machineFirst of all, we can define the state machine where each agent play around inside. The state machine is defined as a YAML file. The following is the example of the state machine definition.states:state0:name:In the housechoices:-action:Go outsidenext:state1-action:Stay insidenext:state0state1:name:Outsidechoices:-action:Go to the supermarketnext:state2-action:Go back homenext:state0state2:name:In the supermarketchoices:-action:Go back homenext:state0entities:-name:A living thingtype:openaiinitial_state:state0The state machine consists of the following two parts.states: The list of states in the state machine.choicesis the list of actions which the agent can take from the state.entities: The list of entities which play around inside the state machine.The CLI script,hakoniwais usable to run the simulation with the state machine definition.$ poetry run hakoniwa -f env.yamlPlease make sure to set theOPENAI_APIKEYif you set the OpenAI entity in the environment.You will see what it does in the environment.INFO:hakoniwa.environment:A living thing,{'action': 'Stay inside', 'next': 'state0'}
INFO:hakoniwa.environment:A living thing,{'action': 'Go outside', 'next': 'state1'}
INFO:hakoniwa.environment:A living thing,{'action': 'Go to the supermarket', 'next': 'state2'}DependenciesInstallPoetryand run the following command to install dependencies.$ poetry installDevelopmentWe can run the unit test with pytest.$ make test
Package: hakowan
HakowanHakowan is a 3D data visualization grammar. It is inspired by the grammar of graphics, and it is
designed for easily creating beautiful 3D visualizations.InstallHakowan relies onLagrangeandMitsubato provide geometry processing and rendering
capabilities. Both Hakowan and its dependencies can be simply installed via pip:pipinstallhakowanNote that hakowan requires python 3.11 and above.Quick startimporthakowanashkwbase=hkw.layer("mesh.obj")# Create a base layerhkw.render(base,filename="image.exr")# Render!DocumentationHTMLAboutHakowan is developed and maintained byQingnan
ZhouandZhicheng Liu.@software{zhou2023hakowan,title={Hakowan: A 3D Data Visualization Grammar},author={Qingnan Zhou and Zhicheng Liu}version={0.1.0},year = 2023,}
Package: hakuna-matata
Hakuna MatataA playing agent for "Hunt the Wumpus".DependenciesTo install the required Python packages, run$pip3install-rsrc/requirements.txtUsage Options-sizeallows to set the size of the generated world, as a positive integer number.-seedallows to set the seed for the world generator, as a hexadecimal number.-worldallows to set the world specification (size, location of pits/wumpus/gold), given as an input file.-agentallows to specify a playing agent for the current game. Possible values are:proxy,perfect,asp.-generateallows to generate a world together with the score obtained by the perfect agent over it, given a base.-benchmarkallows to test an agent against a given benchmark suite.
Package: hakurei-sqlalchemy-graphqlapi
graphql-db-apiA Python DB API 2.0 for GraphQL APIsThis module allows you to query GraphQL APIs using SQL.SQLAlchemy supportThis module provides a SQLAlchemy dialect.fromsqlalchemy.engineimportcreate_engineengine=create_engine('graphql://host:port/path?is_https=0')Example UsageQuerying Connectionsfromsqlalchemyimportcreate_enginefromsqlalchemyimporttext# We use GraphQL SWAPI (The Star Wars API) c/o Netlify:engine=create_engine('graphql://swapi-graphql.netlify.app/.netlify/functions/index')withengine.connect()asconnection:# Demonstration of requesting nested resource of homeworld# and then selecting fields from itforrowinconnection.execute(text("select name, homeworld__name from 'allPeople?include=homeworld'")):print(row)Querying Listsfromsqlalchemyimportcreate_enginefromsqlalchemyimporttextengine=create_engine('graphql://pet-library.moonhighway.com/')withengine.connect()asconnection:forrowinconnection.execute(text("select id, name from 'allPets?is_connection=0'")):print(row)Superset supportIn order to use with Superset, install this package and then use thegraphqlprotocol in the SQLAlchemy URI like:graphql://swapi-graphql.netlify.app/.netlify/functions/index. We install adb_engine_specso Superset should recognize the driver.RoadmapNon-Connections top levelPath traversal (basic)Path traversal (basic + nested)Path traversal (list / connection)Bearer Tokens inAuthorizationHeaderAdvanced Auth (e.g. with token refresh)Passing Headers (e.g. Auth in other locations)FilteringSortingRelay Pagination
Package: hal9
Hal9: Data apps powered by code and LLMsHal9 is a framework for buildinginteractive data apps. It allows you to utilize your DS/ML code with minimal overhead, and frees you from having to worry about frontend web frameworks. Hal9 consists of the following components:LLM: A text interface to design your app using large language models.Getting startedThe quickest place to test things out is this hosted demo:hal9.com/new.Pythonpipinstallhal9importhal9ash9h9.get_app("asks for your name and prints hello")RThe development version of the package can be installed viaremotes::install_github("hal9ai/hal9",subdir="r")library(hal9)h9_start("asks for your name and prints hello")
Package: halalnetwork
2019-net-bWhat is our peer-to-peer file downloading systemThe main idea of the system - secure and reliable file exchange between people in a network.
Peer-to-peer means that files are transfering between guys that are connected to a system following several specific rules:to get into the system the guys first must download the specific .libr filesafterwards those guys must connect to a tracker (using the ip from .libr file) to get the list of other peer guysthe fun begins! Peer goes inside the network, starts taking the "books" (chunks) of needed files from other guys and giving the chunks he has to other guys.In the end everybody is happy having the fully downloaded files.How to build, run, testBuild step:0) runpip install haramnetworksUsechunky_boy.pyto create .libr file (library file as described in protocol) and .bi file (connects names of the stuff with the theirs file-names). The best practise is to run chunky_boy on a tracker computer (because doing so the IP adress of tracker will be writen to .lib file)Users must download this .libr file as a first step (same as if downloading a torrent file)Run steps:2) Runtracker.py. It will activate the tracker of the whole system. Tracker will start to listen, waiting for peers to get connected to it.
3) Runmain_func.py. It will activate peer-to-peer system.Testing step:4) Run pytest -v to run all existing testResourses:5) Check the resourses used vialinkArchitecturesOne player (let's call Player A) execute the 'tracker.py'. Player A will be our hub. Player A has the text file that consist of staffs (The lord of the rings, Gone with the wind etc.).Another one player (Let's call Player B), he will download the libr file (like a bittorrent file) on github. This file contains the information of: Hub, name of the staff (e.g The Lord of the rings), size of the staff, size used for books, SHA1 of each books.After Player B has the .libr file, Player B execute the 'main_func.py'. Player B will be one of the peers.When Player B executed the 'main_func.py', Player A's text file will be updated according to Player B's IPP and Port.
For example;Before Player B's execute, text file looks like:The Lord of the Rings II IPPAfter Player B's execute, text file looks like:The Lord of the Rings II IPP 192.168.43.29:1234 (Player B's IPP and Port)End of the execution of 'main_func.py',
Package: halca1006
halca1006This module provides support for the HAL CA1006 protocol.
It is intended to provide a device driver capability to allow integration of HAL CA1006 multi-zone
amplifiers into home automation systems like Home Assistant.
It can also be run in a standalone mode in order to test connectivity and protocol support.InstallationRun the following to install:pipinstallhalca1006Standalone Usageusage:hal.py[-h][--log_level{debug,info,warning,error,critical}][--hal_hostHAL_HOST][--hal_portHAL_PORT]ExposeHALCA1006multi-zoneamplifier

optionalarguments:-h,--helpshowthishelpmessageandexit--log_level{debug,info,warning,error,critical}Setlogginglevel.Defaultstoerror.--hal_hostHAL_HOSTThehostnameorIPaddressoftheHALCA1006.Defaultstolocalhost.--hal_portHAL_PORTTheHALCA1006IPport.Defaultsto7000.Integrated Usagefromhalca1006importHALProtocol# TODO: Add function examples - see if this can be self documenting from the code?
Package: hal-cgp
Cartesian genetic programming (CGP) in pure Python.hal-cgp is an extensible pure Python library implementing Cartesian genetic programming to represent, mutate and evaluate populations of individuals encoding symbolic expressions targeting applications with computationally expensive fitness evaluations. It supports the translation from a CGP genotype, a two-dimensional Cartesian graph, into the corresponding phenotype, a computational graph implementing a particular mathematical expression. These computational graphs can be
exported as pure Python functions, NumPy-compatible functions (Walt et al., 2011), SymPy expressions (Meurer et al., 2017) or PyTorch modules (Paszke et al., 2019).The library implements a mu + lambda evolution strategy (Beyer and Schwefel, 2002) to evolve a population of individuals to optimize an objective function.Design decisions/use casesWe designed hal-cgp for optimization problems in which individual fitness evaluations are computationally expensive. The library is hence not optimized for high performance, but rather puts ease of use and extensibility first. Furthermore we take steps to reduce the number of redundant fitness evaluations, for example by avoiding reevaluating parents at the beginning of each episode and providing a convenient decorator to cache results on disk. If for your use case individual fitness evaluations are fast and the performance of the library itself becomes a relevant factor, you may want to check outhttps://github.com/darioizzo/dcgporhttp://www.cgplibrary.co.uk/files2/About-txt.html.Figure from Jordan, Schmidt, Senn & Petrovici, “Evolving to learn: discovering interpretable plasticity rules for spiking networks”,arxiv:2005.14149.
Package: hal-cli
HAL 🤖🚧 HAL IS STILL UNDER CONSTRUCTION - PLEASE DON'T MAKE ANY SUDDEN MOVES 🚧HAL manages your machine learning research environment in AWSUsing HAL, you can dynamically provision your perfect machine in AWS - small instances for tinkering with code all the way up to massive GPU instances for training deep learning models. Instance creation and termination is fast, so mode switching is relatively painless, and the costs are kept low by automatically calculating spot instance bids.When they're created, instances attach themselves to your own persistent, floating EBS volume (defined in terraform), where you can store data, notebooks, git repos, etc.Users can access instances via ssh, or through a tunnelled jupyterlab session.Installationpip install hal-cliUsing HALSee theCLI referencefor more detailed documentation.Create a new instancehal start p2.xlargereplacingp2.xlargewith the instance you want.See the full list of instance types in your regionhere.Describe your running instanceshal describeConnect to your instance via sshOpen a new shell on your instance by runninghal connectAlternatively, you can openlocalhost:8888in a browser and interact with your instance through jupyterlab.Move files between your local machine and the remote instancehal put \--local-path /path/to/file/to/send \--remote-path /path/on/instancehal get \--local-path /path/to/save/file/at \--remote-path /path/on/instanceShut down your instancehal stop
Package: halcyon-matrix
Halcyonon and onThe goal of this project is to have an easy to install and use Matrix bot library similar to the Discord or Slack libs.
Encryption must be transparent to the user. Check the roadmap innotes.mdCurrent featuresA nice command prompt to generate Halcyon tokensLogin with token or username/passwordFetch for new messages every x seconds using awaitEvent hooks foron_message(self, message)on_message_edit(self, message)on_room_invite(self, room)on_room_leave(self, roomID)Action hookssend_message(self, roomID, body, textFormat=None, replyTo=None, isNotice=False)async def join_room(self, roomID)documentationgithub whl builderGetting startedCreate an account to use as a bot accountInstall usingpython3 -m pip install halcyon-matrixor using the Releases tabGenerate a token usingpython3 -m halcyon -s homeserver.xyz -u @user:homeserver.xyz -p yourP@$$w0rdStart with the demo belowExample bot codeimporthalcyonimportrequests,jsonclient=halcyon.Client()@client.eventasyncdefon_room_invite(room):"""On room invite, autojoin and say hello"""print("Someone invited us to join "+room.name)awaitclient.join_room(room.id)awaitclient.send_message(room.id,body="Hello humans")@client.eventasyncdefon_message(message):"""If we see a message with the phrase 'give me random', do a reply message with 32 random characters"""if"give me random"inmessage.content.body:body="This looks random: "+requests.get("https://random.wesring.com").json()["value"]awaitclient.send_message(message.room.id,body=body,replyTo=message.event.id)if__name__=='__main__':client.run(halcyonToken="eyJ0eXAiO...")CLI usagehalcyon can be called from the CLI to do some managment of the account. See the readme withpython3 -m halcyon -husage: halcyon [-h] [-s SERVER] [-u USERNAME] [-p PASSWORD] [--include-password] [--decode DECODE] [--pretty] [--revoke REVOKE] [--revoke-all-tokens REVOKE_ALL_TOKENS]

By this, you can generate a halcyonToken for your project, for example python3 -m halcyon -s matrix.org -u @kevin:matrix.org -p on&on&on1337

optional arguments:
  -h, --help            show this help message and exit
  -s SERVER, --server SERVER
                        Homeserver the user belongs to ex: matrix.org
  -u USERNAME, --username USERNAME
                        Your full username ex: @kevin:matrix.org
  -p PASSWORD, --password PASSWORD
                        Your full password for your matrix account
  --include-password    Save your username and password in the token for reauth (Not required right now since matrix tokens do not expire)
  --decode DECODE       Decode an existing token that you pass in
  --pretty              Pretty print the decoded token
  --revoke REVOKE       Revoke an existing token
  --revoke-all-tokens REVOKE_ALL_TOKENS
                        Revoke an all existing token for the account

Have fun creating
Package: halerror
halerrorThe best python exception libraryThis python library implements a sci-fi exception class!InstallationThe package is available fromPyPI.
To install using pip, do the following:pipinstallhalerrorTo install from source, clone this repository and then do the following:pythonsetup.pyinstallTestingTo run the tests, clone this repository and the do the following:pythonsetup.pytestBuilding the documentationTo build the documenation, clone this repository and the do the following:pipinstall-e.[build_sphinx]pythonsetup.pybuild_sphinxUsage examplesThe exception class can be used as follows:fromhalerrorimportHalErrordefopen_pod_bay_doors():raiseHalError("Open the pod bay doors, HAL.")open_pod_bay_doors()This will result in the following error output, where ${NAME} is the username
of the person running the software:halerror.HalError: Open the pod bay doors, HAL

I'm sorry, ${NAME}. I'm afraid I can't do that.Having all your exceptions formatted like this is as easy as adding the
following lines to your codefromhalerrorimportHalErrortry:open_pod_bay_doors()exceptExceptionaserror:raiseHalError(error)fromerrorDocumentationYou can find the full documentation onRead the Docs.IssuesPlease use theGitHub issue trackerto submit bugs or request features.LicenseCopyright James Parkhurst, 2019.Distributed under the terms of the BSD license, halerror is free and open source software.