Saravanan666/pypi-org huggingface dataset:
Package: huber
huberEthernet driver and command-line tool for Huber baths.Installationpip install huberUsageCommand LineFor basic tasks, this driver includes a command-line interface. Read the help
for more.huber --helpPythonFor more complex projects, use python to automate your workflow.This
driver solely uses asynchronous Python ≥3.5.importasynciofromhuberimportBathasyncdefget():asyncwithBath('192.168.1.100')asbath:print(awaitbath.get())asyncio.run(get())If the bath is communicating, this should print a dictionary of the form:{'on':False,# Temperature control (+pump) active'temperature':{'bath':23.49,# Internal (bath) temperature, °C'setpoint':20.0# Temperature setpoint, °C},'pump':{'pressure':0.0,# Pump head pressure, mbar'speed':0,# Pump speed, rpm'setpoint':0# Pump speed setpoint, rpm},'status':{'circulating':False,# True if device is circulating'controlling':False,# True if temperature control is active'error':False,# True if an uncleared error is present'pumping':False,# True if pump is on'warning':False# True if an uncleared warning is present},'fill':0.0,# Oil level, [0, 1]'maintenance':338,# Time until maintenance alarm, days'warning':{# Only present if warning is detected'code':-1,'condition':'','recovery':'','type':''},'error':{# Only present if error is detected'code':-1,'condition':'','recovery':'','type':''}}The maingetmethod strings together multiple TCP requests, and can take >0.5s
to run. If you don't want all the data, you should instead use the following:awaitbath.get_setpoint()# °Cawaitbath.get_bath_temperature()# °Cawaitbath.get_process_temperature()# °C (optionally installed)awaitbath.get_pressure()# mbarawaitbath.get_pump_speed()# rpmawaitbath.get_fill_level()# [0, 1]awaitbath.get_next_maintenance()# daysawaitbath.get_status()# boolean dictionaryawaitbath.get_warning()# None or dictionaryawaitbath.get_error()# None or dictionaryYou can also start, stop, set temperature setpoint, and set pump speed.awaitbath.start()awaitbath.stop()awaitbath.set_setpoint(50)# °Cawaitbath.set_pump_speed(2000)# rpmawaitbath.clear_warning()awaitbath.clear_error()ImplementationThis uses the PB method described inthe manual.
Note that this does not take advantage of the PB package commands, which would
cut down on the data transmission at the cost of extra bath configuration.
This also does not take advantage of the high-accuracy PB data transmission,
as its resolution is unnecessary in most use cases.
Package: hubify
hubifyCreate GitHub-like visualisations from your time series data.Basic Usage# A list of datetimes, where each datetime represents an observationfromdatetimeimportdatetime,timedeltaimportrandom# Import Hubifyfromhubifyimporthubify# Set a seedrandom.seed(42)# Create 400 random eventsevents=[datetime.today()-timedelta(days=random.randint(0,365))for_inrange(400)]# Call hubifyhubify(events)You should see something like thisInstallationpipinstallhubify
Package: hubisModel-pkg-yjko
tensorflow-object-contour-detectionThis is a tensorflow implimentation of Object Contour Detection with a Fully Convolutional Encoder-Decoder Network (https://arxiv.org/pdf/1603.04530.pdf) .REQUIREMENTS :pip install requirements.txtLabel Preparation :To prepare the labels for contour detection from PASCAL Dataset , run create_lables.py and edit the file to add the path of the labels and new labels to be generated . Use this path for labels during training.TRAINING :python train.py \
    --max_to_keep=50 \
    --Epochs=100 \
    --momentum=0.9 \
    --learning_rate=.0000001 \
    --train_crop_size=480 \
    --clip_by_value=1.0 \
    --train_text = ${path to text file} \
    --log_dir = ${path to where logs will be saved} \
    --tf_initial_checkpoint=${PATH_TO_CHECKPOINT} \
    --label_dir = ${path to label directory} \
    --image_dir = ${path to image directory}EVALUATION :python eval.py \
    --checkpoint=${path to checkpoint to be evaluated} \
    --save_preds=${path to folder where predictions will be saved} \
    --image_dir = ${path to image directory} \
    --eval_crop_size=480 \
    --eval_text =  ${path to eval text file}Results :
Package: hubitatmaker
hubitatmakerThis library provides an async Python interface for Hubitat Elevation’s Maker API. It is primarily intended for use with Home Assistant.FeaturesThe main public API in hubitatmaker is the Hub class. This class represents a Maker API instance on a Hubitat hub. When started, a Hub instance will determine the Hubitat hub's MAC address and and download a list of available devices and details about each device.The Hub instance caches state information about each device. It relies on events posted from the Hubitat hub to update its internal state. Each Hub instance starts a new event listener server to receive events from the hub, and updates the Maker API instance with an accessible URL for this listener server.Basic usageimportasynciofromhubitatmakerimportHubasyncdefprint_devices(host,app_id,token):hub=Hub(host,app_id,token)awaithub.start()fordeviceinhub.devices:print(f"{device.name}({device.id})")if__name__=='__main__':host='http://10.0.1.99'app_id='1234'token='<apitoken>'asyncio.run(print_devices(host,app_id,token))APISee theAPI doc.DevelopingTo get setup for development, run$ pdm run initTo test the code, which will type check it and run unit tests, run$ pdm run test
Package: hubitat-maker-api-client
hubitat_maker_api_clientThis library facilitates access to Hubitat'sMaker API. A key innovation is theHubitatCachingClient, which is capable of maintaining a cache of all your devices in a data store of your choice. This can allow you to query device state more efficiently than using the Maker API directly. HubitatCachingClient can be attached to a process that listens to Hubitat's/eventsocketto update the cached device states in real time.Quick StartInstallpip install hubitat-maker-api-clientThis sample code demonstrates how to configure a HubitatCachingClient using yourHOST,APP_ID,ACCESS_TOKENandHUB_IDalong with your custom implementation ofDeviceCache.from hubitat_maker_api_client import DeviceCache, HubitatAPIClient, HubitatCachingClient


class YourDeviceCache(DeviceCache):
   # Override methods for reading and writing
   # device state to your own datastore


_api_client = HubitatAPIClient(
    host=<HOST>,
    app_id=<APP_ID>,
    access_token=<ACCESS_TOKEN>,
    hub_id=<HUB_ID>,
)

client = HubitatCachingClient(
    api_client=_api_client,
    device_cache=YourDeviceCache(),
)


for switch in client.get_on_switches():
    client.turn_off_switch(switch)
    print(f'Turned off {switch}')This sample code demonstrates how to update device state on your HubitatCachingClient by listening to Hubitat's/eventsocket.import asyncio
import websockets
from hubitat_maker_api_client import HubitatEvent

async def listen(uri: str) -> None:
    async with websockets.connect(uri) as websocket:
        while True:
            message = await websocket.recv()
            event = HubitatEvent(json.loads(message))
            client.update_from_hubitat_event(event)

asyncio.get_event_loop().run_until_complete(listen('ws://<HOST_IP>/eventsocket'))
Package: hublib
hublib is a Python library for theHUBzeroscience gateway platform.  It is designed
to be used withJupyternotebooks on the hubs, although the ui module should work in any notebooks.
Hubs running the Jupyter service
include HUBzero andnanoHUB.hublib.ui - Makes it easy to create a simple GUI for scientific code in a Jupyter notebook.  Built
on top ofipywidgetsandpint.hublib.use - Loads hub environment modules.The complete documentation is hosted athttps://hubzero.github.io/hublib/
Package: hubmap-api-py-client
hubmap-api-py-clientPython client for theHuBMAP Cells API;
See also:hubmap-api-js-client.Contributors starthere.UsageInstall from pypi:pip install hubmap-api-py-clientFind cells with different criteria, and intersect resulting sets:$exportAPI_ENDPOINT='https://cells.dev.hubmapconsortium.org/api/'>>>fromosimportenviron>>>fromhubmap_api_py_clientimportClient>>>client=Client(environ['API_ENDPOINT'])>>>[mformindir(client)ifm.startswith('select_')]['select_cells','select_clusters','select_datasets','select_genes','select_organs','select_proteins']>>>gene_symbol=client.select_genes().get_list()[0]['gene_symbol']>>>cells_with_gene=client.select_cells(where='gene',has=[f'{gene_symbol}> 0.5'],genomic_modality='rna')>>>assertlen(cells_with_gene)>0# Select cells from the datasets with the following UUIDs:>>>dataset_a_uuid=client.select_datasets().get_list()[0]['uuid']>>>dataset_b_uuid=client.select_datasets().get_list()[1]['uuid']>>>cells_in_a_len=len(client.select_cells(where='dataset',has=[dataset_a_uuid]))>>>cells_in_b_len=len(client.select_cells(where='dataset',has=[dataset_b_uuid]))>>>cells_in_datasets=client.select_cells(where='dataset',has=[dataset_a_uuid,dataset_b_uuid])>>>cells_in_datasets_len=len(cells_in_datasets)>>>assertcells_in_datasets_len>0>>>assertcells_in_datasets_len==cells_in_a_len+cells_in_b_len# Combine criteria with intersection:>>>cells_with_gene_in_datasets=cells_with_gene&cells_in_datasets>>>assertlen(cells_with_gene_in_datasets)>0# Get a list; should run quickly:>>>cell_list=cells_with_gene_in_datasets.get_list()>>>cells=cell_list[0:10]>>>assertlen(cells)>0>>>assertcells[0].keys()=={'cell_id','modality','dataset','organ','clusters'}More documentation:ExamplesClientpydocResultsSetpydocResultsListpydocOnly some types of objects can be retrieved from other types of objects:where=...Nonecellclusterdatasetgeneorganproteinselect_cells()✓✓✓✓✓✓select_clusters()✓✓✓✓ ✩✩✩select_datasets()✓✓✓✓✶select_genes()✓✓ ✩✓✓ ✩✩select_organs()✓✓✩✶✓ ✩✓✩select_proteins()✓✩✩✩"✓" = Supported by Cells API, and this client."✶" = Supported by Entities API; support in this client ison the roadmap."✩" = Possible connection toASCT-B(Anatomical Structures / Cell Types / Biomarkers)
Package: hubmap-clt
hubmap-cltA command line interface to download multiple files and directories from the Globus file transfer service.OverviewThe HuBMAP Command-Line Transfer uses the Globus cli to transfer files from a manifest file. This file contains the ID (UUID or HuBMAP ID) and the path to the specific file or directory to be downloaded.Installing  and Using hubmap-cltThe HuBMAP Command-Line Transfer requires a local Globus Connect Personal Endpoint to be connected. The user must have an account with Globus and be logged into both the local endpoint as well as the Globus command line interface. Hubmap-clt is available through PyPi and can be installed with:pip3hubmap-clthubmap-clt requirements can be foundhereConsultInstalling hubmap-cltand ConsultUsing hubmap-cltfor full documentation on getting started with hubmap-clt as we as information on the required Globus software.Building and Publishing hubmap-cltSetupToolsandWheelis required to build the clt distribution.Twineis required to publish to PypiBuild the distribution directory with:python3setup.pysdistbdist_wheelfrom within the hubmap-clt project directoryTo publish, from inside the project directory, run:twineuploaddist/*A prompt to enter login information to the hubmap Pypi account will appearFilesThis code contains:__main__.py: Contains the implementation of the command-line interface as well as the logic for the clt.Inside of__main__.pyare the following classes:whoami: Informs the user if they are logged into Globuslogin: Initiates a Globus login using the default web browsertransfer: Sets up a transfer into the user's downloads file. Accepts a single required argument. This argument is the name of a manifest file which contains information on the files to be downloadedbatch_transfer: Calls globus batch transfer for each source collection represented in the manifest file.
Package: hubmap-commons
commonsThis repository contains the code supporting several HuBMAP restful microservices.Getting StartedThe hubmap commons library is available through PyPi via the command:pipinstallhubmap-commonsThe hubmap-commons requirements can be foundhereContentsThe code includes:activity.py(deprecated)creates Cyhper statements for creating and getting HuBMAP Activitiy node typesautherror.pya class to handle authentiation errorsentity.py(deprecated)a base class that executes many Cypher queries against Neo4j to return information about the HuBMAP Entity nodesfile_helper.pycontains methods to execute files and parse filesglobus_file_helper.pycontains methods for creating Globus directorieshm_auth.pycontains several methods and classes relating to system securityhubmap_const.pya file that maintains the names and strings used in the code and the Neo4j systemneo4j_connection.py(deprecated)provides connections to Neo4j and some generic Cypher statements (e.g. CREATE and UPDATE)neo4j_driver.pycreates a neo4j.Driver singleton instanceprovenance.py(deprecated)extracts provenance related information from a tokenschema_tools.pychecks a JSON structure vs a schema definition using two main methods.check_json_matches_schema(jsondata, schema_filename: str, base_path: str = "", base_uri: str = "")Checks the given json data against the jsonschema in the given schema file, raising an exception on error. The exception text includes one or more validation error messages.assert_json_matches_schema(jsondata, schema_filename: str, base_path: str = "", base_uri: str = "")Raises AssertionError if the schema in schema_filename is invalid, or if the given jsondata does not match the schema.stirng_helper.pycontains several string related functions (listToCommaSeparated, getYesNo, etc.)test_ws.pycontains a test Web Service.  This service can be run by copying hubmap_commons/common_app.conf.example to hubmap_commons/common_app.conf and providing a Globus client id and secret (available athttps://developers.globus.org) then directly running test_ws.py from the hubmap_commons/ directory.  The service has a useful /login method that can be used to generate Globus auth tokens for testing.  Note: For much of HuBMAP a Globus "nexus" token used to access the globus Nexus APIs.  To generate a nexus token the Client ID must be authorized for this.  Client IDs are available from the developers of this repository to generate nexus tokens for use against HuBMAP APIs.uuid_generator.py(deprecated)this is a wrapper for calls to the /hmuuid Web Service
Package: hubmap-sdk
hubmap-sdkA Python interface to the various HuBMAP web servicesOverviewThe hubmap sdk is a client library that allows for easy integration of the API's associated with HuBMAP.Using hubmap-sdkThe hubmap-sdk library is available through PyPi via the command:pip3installhubmap-sdkhubmap-sdk requirements can be foundhereDocumentationDocumentation and examples can be found herehubmapsdkentitysdksearchsdkBuilding and Publishing hubmap-sdkSetupToolsandWheelis required to build the sdk distribution.Twineis required to publish to PypiBuild the distribution directory with:python3setup.pysdistbdist_wheelfrom within the python-sdk project directoryTo publish, from inside the project directory, run:twineuploaddist/*A prompt to enter login information to the hubmap Pypi account will appearFilesThis code contains:collection.pyContains the Collection class. This is used for creation and modification of Collection objects.dataset.pyContains the Dataset class. This is used for creation and modification of Dataset objects.donor.pyContains the Donor class. This is used for creation and modification of Donor objects.entity.pyContains the Entity class. This is the base class for the Donor, Dataset, Upload, Collection, and Sample classesentitysdk.pyThis file contains the primary methods used to interface with the Entity Api. These methods are part of the EntitySdk class. An instance of this class is needed to use the various methods in this class. For a detailed breakdown of the various methods within entitysdk.py, visitapi.docs.hubmapconsortium.orgsample.pyContains the Sample class. This is used for creation and modification of Sample objects.sdk_helper.pyThis helper function contains various functions used frequently throughout the sdk. These include make_entity() and make_request()searchsdk.pyThis file contains the primary methods used to interface with the Search Api. These methods are part of the EntitySdk class. An instance of this class is needed to use the various methods in this class. For a detailed breakdown of the various methods within searchsdk.py, visitapi.docs.hubmapconsortium.orgupload.pyContains the Upload class. This is used for creation and modification of Upload objects.
Package: hubot-hangups
This is the description file for the project.The file should use UTF-8 encoding and be written using ReStructured Text. It
will be used to generate the project webpage on PyPI, and should be written for
that purpose.Typical contents for this file would include an overview of the project, basic
usage examples, etc. Generally, including the project changelog in here is not
a good idea, although a simple “What’s New” section for the most recent version
may be appropriate.
Package: hubotlibs
Haidarlibs LibraryCore library ofhaidar-Pyro, a python based telegram userbot.Installationpip3install-Upy-hubotlibsDocumentationSee more working plugins onthe offical repository!Made with 💕 byHaidar.LicenseUltroid is licensed underGNU Affero General Public Licensev3 or later.Credits
Package: hub-rest-client
hub-rest-client0.1.5A client library for accessing Hub REST API⚠️This SDK generated using2021.1.13439OpenAPIversion by customopenapi-python-clientwhich is under development.
It may have some bugs. Use with caution.⚠️If you find a bug or want to request a new feature, please create an issue inYouTrack.UsageFirst, create a client:fromhub_rest_clientimportClientclient=Client(hub_base_url="https://hub.jetbrains.com/api/rest")If the endpoints you're going to hit require authentication, useAuthenticatedClientinstead:importosfromhub_rest_clientimportAuthenticatedClientclient=AuthenticatedClient(hub_base_url="https://hub.jetbrains.com/api/rest",token=os.getenv("HUB_TOKEN"))Now call your endpoint and use your models:fromhub_rest_client.modelsimportMyDataModelfromhub_rest_client.api.my_tagimportget_my_data_modelfromhub_rest_client.typesimportResponsemy_data:MyDataModel=get_my_data_model.sync(client=client)# or if you need more info (e.g. status_code)response:Response[MyDataModel]=get_my_data_model.sync_detailed(client=client)Or do the same thing with an async version:fromhub_rest_client.modelsimportMyDataModelfromhub_rest_client.api.my_tagimportget_my_data_modelfromhub_rest_client.typesimportResponsemy_data:MyDataModel=awaitget_my_data_model.asyncio(client=client)response:Response[MyDataModel]=awaitget_my_data_model.asyncio_detailed(client=client)Things to know:Every path/method combo becomes a Python module with four functions:sync: Blocking request that returns parsed data (if successful) orNonesync_detailed: Blocking request that always returns aRequest, optionally withparsedset if the request was successful.asyncio: Likesyncbut the async instead of blockingasyncio_detailed: Likesync_detailedby async instead of blockingAll path/query params, and bodies become method arguments.If your endpoint had any tags on it, the first tag will be used as a module name for the function (my_tag above)Any endpoint which did not have a tag will be inhub_rest_client.api.default
Package: hubris
HubrisHubris is a simple library for implementing inter-process communication (IPC)
between separate Python processes. It's based on named pipes created by the
POSIXmkfifosystem call.Hubris uses the "channel" metaphor. You can send and receive data on a with
simple send and receive commands. Alternatively, you can have multiple
processes subscribe to the a single channel on which data is published
asynchronously or at a regular interval.Sending Datahub=Hub()channel=hub['example']# send data (which is serialized internally)channel.send({'foo':'bar'})hub.close()Receiving DataReceiving data can be done synchronously or asynchronously.hub=Hub()channel=hub['example']# block until we receive the datadata=channel.receive()# ...or immediately return a future objectfuture=channel.receive(wait=False)data=future.result(timeout=1)hub.close()Publishing DataData can be published at a regular interval.hub=Hub()channel=hub['example']# send data (which is serialized internally)channel.publish({'foo':'bar'},interval=timedelta(seconds=1))# ...or generate data with a callbackchannel.publish(generate,interval=timedelta(seconds=1))# ...or just send data as normally to have it published to subscriberschannel.send({'foo':'bar'})hub.close()Subscribing to ChannelsYou can subscribe a callback to receive and respond to data published on a channel.hub=Hub()channel=hub['example']# subscribe this thread to the channel, triggering# callback upon receipt of datachannel.subscribe(lambda:subscription,data:print(data))hub.close()
Package: hub-shm
Hub Shared MemoryThis package provides a backport of the Python 3.8's shared_memory module that works for 3.6 and 3.7.
This is based off dillonlaird's Shared Numpy array but is leaner.InstallTo install runpip install hub_shm.Installation will only work on Python 3.6.x and 3.7.x.Usageimporthub_shmasshmYou can then accessshm.SharedMemoryandshm.ShareableListwhich are the same as the
ones in Python 3.8'sshared_memorymodule.
Package: hubspace
hubspace-pyhttps://pypi.org/project/hubspace/1.0.0/tools for intergrading with hubspace though pythoninstalling:pip install hubspacegetting started:fromhubspaceimportHubspacehubspace=Hubspace(username,password)examples:# get json info for all deviceshubspace.getDeviceInfo()# get array of all device objectsdevices=hubspace.getDevices()# get target device objectdevice=hubspace.getDevice(deviceID)# get additional information about devicesstates=hubspace.getDeviceStates()tags=hubspace.getDeviceTags()attributes=hubspace.getDeviceAttributes()# get all data for all devicesself.getDevices(["state","tags","attributes"])# get device metadatahubspace.getMetadata()# get conclave access informationhubspace.getConclaveAccess()# get the id of this devicedevice.getID()# get the hubspace that created this devicedevice.getHubspace()# get the info for this devicedevice.getInfo()# get additional information about this devicedevice.getState()device.getTags()device.getAttributes()# get metadata for this devicedevice.getMetadata()# get the name of this devicedevice.getName()# set the name of this devicedevice.setName()# get the default name for this devicedevice.getDefaultName()# get the name of the manufacturer of this devicedevice.getManufacturerName()# get the model number for this devicedevice.getModel()# get the class of the device (ie. light, fan ...etc)device.getDeviceClass()# read an action type for this device (see getgetAttributes for action info)device.readAction(actionID)# write action data for this devicedevice.writeAction(actionID,actionData)
Package: hubspot
====================HubSpot Api Wrapper===================HubSpot API Wrapper for python. not a complete packageTo Install for Development testing:pip install hubspot --preto upgrade packagepip install hubspot --pre --upgradeUsage:portal = HubSpot(portal_id="YourPortal", hapikey="YOUR_HAPI_KEY")Modules:portal.filesportal.contactsportal.propertiesportal.formMore to come.