Saravanan666/pypi-org huggingface dataset:
Package: homemate-bridge
========Overview========Orvibo "Homemate" to MQTT bridge* Free software: Apache Software License 2.0Supported Devices=================* Orvibo S20cIf you've managed to the bridge working with other devices, please open an issue so I can update the list!Requirements============* Python 3.x, on Linux* The python3-dev, build-essential and libssl-dev packages (for Debian-based systems, or the equivelant)* One or more supported switches* HomeAssistant* An MQTT broker connected to HomeAssistantInstallation============* Obtain the Orvibo 'PK' key (see below) as a `keys.json` file* Redirect all traffic for homemate.orvibo.com, TCP port 10001 to the machine running the bridge. The easiest way to do this is to override the DNS record, but how you can do this will greatly depend on how your network is set up* `Configure HomeAssistant <https://home-assistant.io/docs/mqtt/discovery/>_` to discover MQTT devices* Install the bridge:::pip install homemate-bridge* Run the bridge:::homemate-bridge --keys-file <path/to/key/file> --mqtt-host ...* After ~30 seconds you should see devices connecting to the bridge, and new switch entities in HomeAssistantGetting the Orvibo 'PK' encryption key======================================As part of the initial handshake with the server, the switch sends a 'hello' packet encrypted with a static key, and expects a packet encrypted with the same key in response that sets a different key for all subsequent packets. This is the 'PK' key, and is not included with the source code until I work out if there would be legal issues with doing so. Fortunately, Orvibo hardcode this key in the source code of the 'Kepler' Android app.* Download the `Kepler apk <http://www.orvibo.com/software/android/kepler.apk>_`* Run the `homemate-bridge-seed-keyfile --keys-file keys.json <path/to/apk>` script to extract the key and save it. Note that the file will be overwritten if it exists.Documentation=============https://homemate-bridge.readthedocs.io/Development===========To run the all tests run::toxChangelog=========0.0.1 (2017-07-11)------------------* First release on PyPI.
Package: homeostasis
<pre><h1>homeostasis</h1><h2>description</h2>This is a module that can reliablyascertain the health status of software.(It's like a testing kit)<h2>install</h2>[SH] pip install homeostasis<h2>documentation</h2>[SH] homeostasis shares<h2>homeostasis of homeostasis (the internal homeostasis of the homeostasis module)</h2><p>These checks are run with pypi "body_scan"</p><p>"homeostasis" is a fork of "body_scan"</p><p>("body_scan" checks are written with "unittest")</p>[SH] homeostasis homeostasis<h2>health checks</h2><p>Checks are started simultaneously, unless "--simultaneous no"</p><h3>create a status file</h3># status_1.pydef check_1 ():print ("check 1")def check_2 ():print ("check 2")def check_3 ():raise Exception ("not 110%")checks = {"check 1": check_1,"check 2": check_2,"check 3": check_3}<h3>start from a directory deeper than the status file "status_1.py"</h3>[SH] homeostasis status<h3>The report then should appear like this:</h3><code>paths: [{"path": "../status_1.py","empty": false,"parsed": true,"stats": {"passes": 2,"alarms": 1},"checks": [{"check": "check 1","passed": true,"elapsed": [4.054199962411076e-05,"seconds"]},{"check": "check 2","passed": true,"elapsed": [1.72930003827787e-05,"seconds"]},{"check": "check 3","passed": false,"exception": "Exception('not 110%')","exception trace": ["Traceback (most recent call last):","  File \"/home/veganecology/.local/lib/python3.11/site-packages/homeostasis/processes/scan/process/keg/check.py\", line 68, in start","    checks [ check ] ()","  File \"<string>\", line 13, in check_3","Exception: not 110%"]}]}]alarms: [{"path": "../status_1.py","checks": [{"check": "check 3","passed": false,"exception": "Exception('not 110%')","exception trace": ["Traceback (most recent call last):","  File \"/home/veganecology/.local/lib/python3.11/site-packages/homeostasis/processes/scan/process/keg/check.py\", line 68, in start","    checks [ check ] ()","  File \"<string>\", line 13, in check_3","Exception: not 110%"]}]}]stats: {"alarms": 0,"empty": 0,"checks": {"passes": 2,"alarms": 1}}</code><h2>advanced configurations</h2><p>It's recommended to run homeostasis programmatilly.An example of this can be found in the "advanced configurations"section of the documentation.</p><h2>Contacts</h2><p>status600@proton.me</p></pre>
Package: homepanelapi
homepanelapiPython Package for Home Panel's API.InstallInstallationRequires Python version 3.6+pipinstallhomepanelapiExamplehomepanelapi--hostlocalhost--port8234--usernameusername--passwordpassword--pageHome--cardImage--commandexpandCLI optionsparamaliasdescription--host-hHome Panel's Hostname.--port-PThe Home Panel Port.--ssl-sUse ssl?--username-uYour Home Panel Username.--password-pYour Home Panel Password.--endpoint-eThe path after the host and port.--data-dData to send.
Package: homer
Homer allows to manage the lifecycle of the configuration for network devices, generating and deploying their
configuration.The configuration generation is based onYAMLfiles to define variables andJinja2templates.
TheYAMLfiles allow for hierarchical override of variables based on the device role, site or hostname.
Once generated, the configuration can be deployed to the selected devices.The device list can either live hardcoded in the configuration files or be dynamically gathered from Netbox.
When using Netbox as inventory both the Virtual Chassis endpoint and the Device endpoint are used to select
all the devices that matches the configured whitelist of device roles and statuses.Also when using Netbox as inventory for each device additional metadata is exposed to the templates, namely:role: device role slugsite: device site slugtype: device type slugip4: primary IPv4 without netmaskip6: primary IPv6 without netmasknetbox_object: the Netbox device object. Directly exposed data should always be preferred in templates.
It is exposed to not be a blocker in case some additional data is needed that is not yet exposed by
Homer explicitely. It could be removed in a future release.If any metadata is present in theYAMLinventory file when using Netbox as inventory, this additional metadata
ie exposed too to the templates, with the Netbox values having precedence in case of overlapping keys.When using Netbox to gather dynamic configuration, it’s also possible to write a custom plugin in the form of a
Python module that implements a class calledNetboxDeviceDataPluginthat inherits fromhomer.netbox.BaseNetboxDeviceDataand is in the PythonPATH.
Assuming that the plugin class implements a method named_get_name, it will be accessible within the templates
withnetbox.device_plugin.name.
Package: home-run
# DLHub home_run[![CI](https://github.com/DLHub-Argonne/home_run/actions/workflows/CI.yml/badge.svg)](https://github.com/DLHub-Argonne/home_run/actions/workflows/CI.yml)
[![Coverage Status](https://coveralls.io/repos/github/DLHub-Argonne/home_run/badge.svg?branch=master)](https://coveralls.io/github/DLHub-Argonne/home_run?branch=master)
[![PyPI version](https://badge.fury.io/py/home-run.svg)](https://badge.fury.io/py/home-run)home_runis a tool used by [the Data and Learning Hub for Science](https://www.dlhub.org) internally to turn a bunch of files and a recipe into an functional Python object.## Installationhome_runis on PyPi. Install it by calling`bash pip install home_run `home_runis designed to be as light-weight as possible, and has onlyrequestsas a dependency.## Technical DetailsThe key ingredients for usinghome_runare files describing a function that will be served by DLHub.
These include a metadata file describing the servable (see
[dlhub_sdk](http://github.com/dlhub-argonne/dlhub_sdk) for tools for creating these files,
and [dlhub_schemas](http://github.com/dlhub-argonne/dlhub_schemas) for the schemas), and
the actual files that make up the servable (e.g., a Keras hdf5 file).Each particular type of servable has its own recipe for going from these files to a Python object.
All recipes are a subclass ofBaseServable, which provides the general framework for defining a servable object.
Each subclass has a matchingBaseMetadataModelclass indlhub_sdk.
For example, the type of servable that can be described by thePythonStaticMethodModelcan be run by thePythonStaticMethodServable.## Project Support
This material is based upon work supported by Laboratory Directed Research and Development (LDRD) funding from Argonne National Laboratory, provided by the Director, Office of Science, of the U.S. Department of Energy under Contract No. DE-AC02-06CH11357.
Package: homescraper
homescraperMonitor your apartments searches on casa.it, immobiliare.it, subito.it, ... and notify by SMS when new apartments are published.NoteSteps to follow to install and run this tool:Installpip install homescraperorgit clone https://github.com/asabellico/homescraper
cd homescraper
pip install .Create a config filecp config.yml.example config.ymlCollect your searches URLs from your favourite website and add them in yourconfig.ymlfile in thequeriessectionInsert your Twilio access keys inconfig.ymlRunhomescraper config.yml --timeout 15It will init its internal DB and alert you on new published apartments
Package: home-service
Home ServiceHome service is a simple IoT server that serves REST endpoints for
IoT devices to post sensor data, and a simple web interface for monitoring.Invoking the commandhome-servicewill start the server. This is preferably
wrapped in a systemd service and ran as a daemon. Containerised deployment options
are being worked on.InstallationUsing pip:python3-mpipinstallhome-serviceUsageUsage:home-service[options]OptionsOptions:--version,-vGetversioninfoandexit--help,-hPrintthismessageandexit--port,-pTCPporttoruntheserver,defaultstoport6613
Package: homeslice
# homeslicedotfiles and :pizza: management[![image][homesick_pypi]][homesick_pypi_web] [![image][homesick_license]][homesick_license_web]Homeslice is originally based on [pyhome][pyhome] by Andrew Crozier.## TODOThis is a simple python utility with similar functionality to the
functionality of the [homesick][homesick] ruby utility, providing a simple
interface for managing dotfiles via git repositories.This port exists because I wanted an easier to extend version of [homesick][homesick] and [pyhome][pyhome].[homesick]:https://github.com/technicalpickles/homesick[homesick_license]:http://img.shields.io/badge/license-MIT-green.svg[homesick_license_web]:https://github.com/jefftriplett/homeslice/blob/master/LICENSE[homesick_pypi]:http://img.shields.io/pypi/v/homeslice.svg[homesick_pypi_web]:https://pypi.python.org/pypi/homeslice[pyhome]:https://github.com/acroz/pyhome0.2.0:Fixes git clone command0.1.0:Initial version
Package: homevision-netio-controller
HomeVision NetIO ControllerA python api for controlling a homevision system via the netio interface.The commands are sent over the a socket to the netio server running in HomeVision XL.How to use:fromhomevision_netio_controllerimportHomeVisionController,Macroactions={"HOT WATER 1 HOUR":Macro(42)}controller=HomeVisionController("192.168.1.100",9999,"f498m0M9j87Hj743RgK8HI",actions=actions)controller.action_command({"command":"HOT WATER 1 HOUR"})For more information on NetIO visit it'shomepageFor more information on NetIO Homevision plugin visit thewebsiteFor more information on further commands see the help pages of the plugin.
Package: homewizard-climate-websocket
homewizard-climate-websocketAPI/Websocket to control Homewizard Climate devicesThis library allows you to control your Homewizard Climate devices. There are a multitude of brands that use Homewizard apps for their smart controls.This was developed in oder to be used in aHome Assistantintegration. It has not been thoroughly tested or worked with as a standalone code.Supported DevicesThis library is in an early stage of development and only works for the following device types returned from the Homewizard Climate API:heaterfanIt has been tested on the following devices (even though it might work on others too):Princess Smart Heating and Cooling Tower (01.347000.01.001)Quick startThere's no separaterequirements.txtfile, the dependencies can be found and installed insetup.pyusername = os.environ["HW_CLIMATE_USERNAME"]
password = os.environ["HW_CLIMATE_PASSWORD"]
api = HomeWizardClimateApi(username, password)
api.login()
devices = api.get_devices()
ws = HomeWizardClimateWebSocket(api, devices[0])
ws.connect_in_thread() # There's also a blocking `connect`
time.sleep(5)InstallationStable Release (PyPi):pip install homewizard_climate_websocketLocal Development:pip install .DevelopmentAny help to increase the number of supported devices is much appreciated as I only had access to the one mentioned above.SeeCONTRIBUTING.mdfor information related to developing the code.
Package: homewizard-climate-ws
homewizard-climate-websocketAPI/Websocket to control Homewizard Climate devicesThis library allows you to control your Homewizard Climate devices. There are a multitude of brands that use Homewizard apps for their smart controls.This was developed in order to be used in aHome Assistantintegration. It has not been thoroughly tested or worked with as a standalone code.Supported DevicesThis library is in an early stage of development and only works for the following device types returned from the Homewizard Climate API:heaterfaninfraredheaterheaterIt has been tested on the following devices (even though it might work on others too):Princess Smart Heating and Cooling Tower (01.347000.01.001)Princess Smart Infrared Panel Heater 350 (01.343350.02.001)Princess Smart Glass Panel Heater (01.342001.09.001)Quick startThere's no separaterequirements.txtfile, the dependencies can be found and installed insetup.pyusername = os.environ["HW_CLIMATE_USERNAME"]
password = os.environ["HW_CLIMATE_PASSWORD"]
api = HomeWizardClimateApi(username, password)
api.login()
devices = api.get_devices()
ws = HomeWizardClimateWebSocket(api, devices[0])
ws.connect_in_thread() # There's also a blocking `connect`
time.sleep(5)InstallationStable Release (PyPi):pip install homewizard_climate_websocketLocal Development:pip install .DevelopmentAny help to increase the number of supported devices is much appreciated as I only had access to the one mentioned above.SeeCONTRIBUTING.mdfor information related to developing the code.
Package: homewizard-kitchen
python-homewizard-kitchenThis package connects to the HomeWizard Kitchen's websocket to get & update a device status.
This project currently only implements the Kettle device.
Tested on a HomeWizard Kettle 1.4,HWK-KTL 1.07Installationpip install homewizard-kitchenUsageSeeexample.pyAfterwards you can use the Kettle model to update & retrieve data.
Package: homework
homeworkThis library lets you easily set up programing homeworksA homework is defined as two files, one with some lines changed according
to the language defined by the library (see the docs) and anotherone with
the solution. The solution file is encrypted so that the student's do not
have it.The rules are simple instructions that you add as comments to your code. All
commands are structured as follows## homework:[cmd]:[flag]. Here is an
example:## homework:replace:on#.dw =#.w =dw=compute_gradients()w-=alpha*dw## homework:replace:offWhenparsingtheabovecode,theAPIwillproduceasolutionfileencryptedandtheoriginalcodewillbereplacedwith:## homework:startdw=w=## homework:endUsageFirst runpython homework.py make testfile.py, which returns theencryption keyand creates the following files:testfile_homework.py, which contains some broken lines so that the students can fill the gaps.testfile_solution.py, which is the encrypted version of the source file (testfile.py)Now you could send your studentstestfile_homework.pyand remove the originaltestfile.pywhile keeping theencryption key. This way only people with the key can uncover the solution to the homework, by enteringpython homework.py uncover testfile_solution.py [encryption key]in the terminal.Future workSupport for defining homeworks out of jupyter notebooksAutomatic gradingPerhaps something you want to suggest!
Package: homework-checker
Homework checkerThis is a python module and script that can be used to check homeworks.The idea behind the script is the following:There is a homework yaml file, seehomework.ymlthat follows theschemaIn this file we define the structure of the homeworkThe homework checker library knows how to execute certain types of tasks following the guides in the yaml fileIt is expected that the submitted homework will follow the folder structure specified in thehomework.ymlfile.Core functionalityRun different testsFor now we support running tests for code written in different languages:c++bashInject data into homeworksWe sometimes want to inject a certain folder before running tests, there is an option to do this here.How it worksI will probably not go into details here at this level of the package maturity. For now you can start digging from thecheck_homework.pyscript and hopefully the code is clear enough. You can also look at thehomework.ymlfile that we use to test all the implemented functionality.
Package: homi
homimicro grpc framework like flaskinstallpipinstallhomiFeatureconfig less to run serveruse decorator pattern to connect service methodauto parse request data to dict, you don't use grpc request objectauto set argument what you wantsupport all grpc service type(unary-unary,unary-stream,stream-unary,stream-stream)TLS supportyou just return dict type, not grpc objectsupport async grpc servertest your server very easy(HomiRealServerTestCase(support sync & async server), HomiTestCase(only sync server))Examplecheck moreexamplefromhomiimportApp,Serverfromhomi.extend.serviceimportreflection_service,health_servicefromhelloworld_pb2importDESCRIPTORsvc_desc=DESCRIPTOR.services_by_name['Greeter']app=App(services=[svc_desc,reflection_service,health_service,])# unary-unary method@app.method('helloworld.Greeter')defSayHello(name,**kwargs):print(f"{name}is request SayHello")return{"message":f"Hello{name}!"}# or@app.method('helloworld.Greeter','SayHello')defhello(request,context):print(f"{request.name}is request SayHello")return{"message":f"Hello{request.name}!"}# ordefhello_func(request,context):return{"message":"hi"}app.register_method('helloworld.Greeter','SayHello',hello_func)if__name__=='__main__':server=Server(app)server.run()Service ExampleThe service class is similar to the blueprint of flask. You can separate files on a service basis or add services created by others.
Also, we will be able to override the method already registered in the future.fromhomiimportApp,Server,Servicefromhomi.extend.serviceimportreflection_service,health_servicefromhelloworld_pb2importDESCRIPTORapp=App(services=[reflection_service,health_service,])greeter=Service(DESCRIPTOR.services_by_name['Greeter'])@greeter.method()defSayHello(name,**kwargs):print(f"{name}is request SayHello")return{"message":f"Hello{name}!"}# you can share service to pypiapp.add_service(greeter)run server# if app file name is app.pyhomirun# run ohter app filehomirunother_app.py# change porthomirun-p50055# change total workerhomirun-w5# run TLS serverhomirun--private_keyserver.key--certificateserver.crtRelation Projectgrpc_requests: GRPC for Humans! python grpc reflection support clientChange Logs0.2.2HotFix for TypedDict compatibility issue0.2.1Feature
- 3.6, 3.7 compatibility support0.2.0Feature#37 : support AsyncIO API Server!example0.1.7Fix Bugsremove HomiRealServerTestCase, HomiTestCase frominit.py, please import test class directadd cryptography dependency0.1.6Feature#30 : support atls server [Experimental]0.1.5Feature#29 : support tls server0.1.1Fix Bugs#23 : change support python version >= 3.8 (for TypedDict)#22 : remove handler wrapper self arguments0.1.0Breaking Change!!! #19Add Appnow you must make server using App class!Add ServiceYou can separate the code by service or method.Add Confignow you can use service config and overwrite in app0.0.4.alphaadd real server testcasesupport grpc-health0.0.3support all method typeadd flak8 lintadd test case#9 auto parse response message0.0.1 (init project)run server using clihelloworld example
Package: homieclient
Python Homie clientThis is a very basic implementation of a client for IoT devices following theHomieMQTT convention. Currently, it only
really supports sensor-like devices, i.e., those devices that publish retained
non-settable properties, as this is at this point in time the only use-case
I personally have for it.UsageCreate an instance of the client, and connect it to your MQTT server:from homieclient import HomieClient

c = HomieClient(server='10.42.0.1')Various callbacks can be registered, that will be called when a device, a node
or a property is discovered or updated:# Called when a new device is found. Note that at this point not all the nodes
# of the devices might be discovered yet.
def device_discovered(device):
    print("Found device %s, state is %s" % (device.name, device.state))
c.on_device_discovered = device_discovered

# Called when an attribute on the device changes, such as $state
def device_updated(device, attribute, value):
    print('Device %s updated: %s = %s' % (device.name, attribute, value))
c.on_device_updated = device_updated

# Called when a node on a device is found. The device for this node can be
# accessed via node.device.
def node_discovered(node):
    print('Found node %s on device %s' % (node.name, node.device.name))
    print('Node properties: %s' % node.properties)
c.on_node_discovered = node_discovered

# Called when an attribute on a node changes.
def node_updated(node, attribute, value):
    print('%s, node %s: %s = %s' % (node.device.name, node.name, attribute, value))
c.on_node_updated = node_updated

# Called when a new property on a node is found.
def property_discovered(node, property):
    print('Found property %s on node %s, device %s' % (property, node.name, node.device.name))
c.on_property_discovered = property_discovered

# Called when a property on a node is updated. The value is a dict
# containing the name, value and unit of the property
def property_updated(node, property, value):
    print('%s: %s = %s' % (node.name, property, repr(value)))
c.on_property_updated = property_updatedAfter registering the callbacks you need to connect the client to the broker:c.connect()It is also possible to access all the devices, nodes and properties via the
client, without using any of the callbacks. Every device is exposed as a property
on the client, the nodes are exposed as properties on the device, and the properties
as properties on the node. So if you have a device with idoutdoor_sensorwith
nodesensorand propertytemperature, you can dotemperature = c.outdoor_sensor.sensor.temperature
print('%s: %.1f %s' % (temperature.name, temperature.value, temperature.unit))This will print something likeTemperature: 21.4 °Cassuming the name of the property isTemperature, and it reports afloatvalue,
and the weather is quite nice.