Saravanan666/pypi-org huggingface dataset:
Package: tuxput
tuxputThe Serverless File Uploadertuxput is a python/flask application which provides a file uploading interface
to S3, and is designed to be run serverlessly withZappa.ConfigurationConfiguration is handled by a JSON file stored in S3 and some
environment variables that must be set in order to access it.Environment VariablesThe following configuration variables should be set when running
tuxput:CONF_BUCKETrequired: Truedescription: S3 bucket name containing the configuration. Example:testing-tuxput-authCONF_FILErequired: Falsedescription: String that is the key (filename) of a json file containing
user with access and the buckets to which they may upload.  Defaults to
'tuxput.json'S3_REGIONrequired: Truedescription: Region containing the S3 bucket. Example:us-east-1SITE_TITLErequired: Falsedescription: Defaults toTuxput. Set to anything you like for a global
site title.ALLOW_UPLOAD_OVERWRITErequired: Falsedescription: boolean, defaults to False.  Allows uploaders to overwrite
existing files.JSON ConfigurationTheCONF_FILEprovides configuration information for buckets that are
served and the users that may access them.  An example may be found in
the filesample-tuxput.json.  There are two top level JSON objects that
are listed here:  buckets and usersbuckets"buckets" is a list of dicts consisting of:name           : The name of the bucket in S3
root (optional): Specifies an offset directory from the root of the S3 share.If not "root" setting is available for the bucket, then tuxput assumes that
"/" is the root.users"users" is a list of dicts describing the users that are allowed to upload
to the server.  The only two required options are:token          : The token that is used to identify the user
authorizations : a list of authorizations for the user"authorizations" are made up of:bucket          : a pattern to match for the name of the S3 bucket for which
the authorization rule applies
restricted_paths: a list path patterns where the user is allowed to upload
(will default to "*" and grant full access if not specified)Any other fields in the file are ignored, but may be used to record
administratively interesting information (ie, username or email assocaited
with the token, when the token was created, etc).Run LocallyTo run locally, install tuxput, ensure AWS access is available environmentally,
and run:CONF_BUCKET=testing-tuxput-authS3_REGION=us-east-1FLASK_APP=tuxputflaskrunRun with ZappaThis application is intended to be ran and deployed withZappaand hosted by AWSAPI
GatewayandLambda.To use with Zappa, create an app shim named zappa_init.py:# When using a flask app factory, this file is required.# See https://github.com/Miserlou/Zappa/issues/1771# and https://github.com/Miserlou/Zappa/pull/1775fromtuxpubimportcreate_appapp=create_app()An example zappa_settings.yaml file may look like:{---prod:app_function:zappa_init.appaws_region:us-east-1project_name:testing-tuxputruntime:python3.7s3_bucket:testing-tuxputdomain:testing-tuxput.ctt.linaro.orgcertificate_arn:arn:aws:acm:us-east-1:49557002050:certificate/92772d7-0d15-48d1-a707-010ec561c10environment_variables:CONF_BUCKET:testing-tuxput-authS3_REGION:us-east-1
Package: tuxrun
Documentation-Repository-IssuesTuxRun, byLinaro, is a command line tool for
testing Linux on QEMU or FVP, using curated test suites.  TuxRun is a part ofTuxSuite, a suite of tools and services to help with
Linux kernel development.[[TOC]]About TuxRunTesting the Linux kernel is as simple as using QEMU but it gets complicated
when you want to support the following combinations:Architectures (arm64, armv5, armv7, i386, mips32, mips32el, mips64, mips64el,
ppc32, ppc64, ppc64le, riscv64, s390, sh4, sparc64, x86_64)Emulation systems (QEMU or FVP)Tests (every test suite has dependencies on the rootfs)Each of those items requires specific configuration and root file systems. In
order to allow for reproducible tests, TuxRun uses containers runtimes (Docker
or Podman).Installing TuxRunThere are several options for installing TuxRun:From PyPIRun uninstalledUsing TuxRunTo use TuxRun, compile your own linux kernel for arm64, for example usingTuxMake.Then call tuxrun:tuxrun--deviceqemu-arm64--kernel/path/to/ImageTuxRun will automatically start qemu-system with the right arguments and the
right root filesystem.Known issuesKnown issues when booting on different virtual platforms.From issuesExamplesBoot test a mipsel kernel athttps://mykernel.org/vmlinux:tuxrun--deviceqemu-mips32el\--kernelhttps://mykernel.org/vmlinuxRunningltp-smoke:tuxrun--deviceqemu-mips32el\--kernelhttps://mykernel.org/vmlinux\--testltp-smokeUsing a custom root file systemtuxrun--deviceqemu-mips32el\--kernelhttps://mykernel.org/vmlinux\--rootfshttps://mykernel.org/rootfs.tar.xz
Package: tuxtrigger
Documentation-Repository-IssuesTuxTrigger, byLinaro, is a command line tool for controlling changes in repositories.TuxTrigger is a part ofTuxSuite, a suite of tools and services to help with
Linux kernel development.[[TOC]]About TuxTriggerTuxTrigger allows to automatically track a set of git repositories and branches. When a change occurs, TuxTrigger will build, test and track the results using Tuxsuite and SQUAD.Installing TuxTriggerThere are several options for using TuxTrigger:From PyPIDebian packagesRPM packagesRun uninstalledUsing TuxTrigger!!! note
- TuxTrigger requires TuxSuite and SQUAD accounts (TuxSuite and SQUAD tokens).To use TuxTrigger:CreateTuxSuiteaccount and provide TUXSUITE_TOKEN as environment variable.CreateSQUADaccount and provide SQUAD_TOKEN and SQUAD_HOST as environment variable.
Example:SQUAD_HOST=https://qa-reports.linaro.orgInstall TuxTriggerCreate configuration.yaml fileProvideplan.yamlfile(s) fromTuxSuiteRun TuxTriggerCall tuxtrigger:tuxtrigger/path/to/config.yamlTuxtrigger will automatically start.
Package: tuya-api
tuya-apituya-api is a lib that make you easier to usetuya's api.Installpipinstalltuya-apiExampleimportloggingimporttornado.ioloopimporttornado.webfromtornadoimportgenfromtuya_apiimportTuyaty=Tuya(client_id='your client_id',secret='your secret',schema='you schema')classTokenHandler(tornado.web.RequestHandler):defdata_received(self,chunk):pass@gen.coroutinedefget(self):try:ret=yieldty.get_access_token()returnself.write(ret)exceptExceptionase:logging.exception(e)defmain():app=tornado.web.Application([(r"/token",TokenHandler)])app.listen(8888)print("="*100)print("* Server: Success!")print("* Host:   http://localhost:8888")print("* Quit the server with Control-C")print("="*100)tornado.ioloop.IOLoop.instance().start()if__name__=='__main__':main()DocumentdocumentAuthorFeiben(feiben.dev@gmail.com)
Package: tuya-ble
tuya_bleLibrary to control Tuya BLE devicesFree software: MIT licenseDocumentation:https://tuya-ble.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2023-03-12)First release on PyPI.
Package: tuya-bulb-control
Tuya Bulb ControlTuya Bulb Control - API wrapper for you smart bulbsdeveloped by TuyaInstallationInstall or upgrade tuya-bulb-control:$ pip install tuya-bulb-control --upgradeOr install source:$ git clone https://github.com/Octoober/tuya-bulb-control.git
$ cd tuya-bulb-control
$ python setup.py installDemo:fromtuya_bulb_controlimportBulbCLIENT_ID=''SECRET_KEY=''DEVICE_ID=''REGION_KEY='eu'bulb=Bulb(client_id=CLIENT_ID,secret_key=SECRET_KEY,device_id=DEVICE_ID,region_key=REGION_KEY)# Turn on the bulbbulb.turn_on()# Change the color to greenbulb.set_colour_v2(rgb=(0,255,0))# Turn off the light bulb after 5 minutesbulb.set_toggle_timer(value=5)Getting access to APIStep 1: CLIENT_ID and SECRET_KEYRegister or Login onTuya.Create a cloud development projectCloud -> Project.After successful creation, you will receive theClient IDandSecret Key.Step 2: DEVICE_IDInstallTuya Smartapp orSmart Lifeapp on your mobile phone.Go toCloud -> Link Devicespage.Selecting a tabLink Devices by App Account.ClickAdd App Accountand scan the QR code withTuya Smartapp orSmart Lifeapp.Now you can go to devicesCloud -> Device Listand copyDevice ID.Notes: Try to select a your region if devices are not displayed.Step 3: Request access to API callsGo toCloud -> API Groupand enableAuthorization management,Device ManagementandDevice Control.Done!
Package: tuya-connector-python
tuya-connector-pythonThetuya-connector-pythonSDK is designed to support openAPIs and Pulsar messages provided by Tuya. Before using this SDK, you can seeQuick Starton the Tuya Developer website to learn more about Cloud Development Platform.Installpip3 install tuya-connector-pythonGet startedSign upfor Tuya developer account.Create a cloud project. See thetutorialfor how to get the authorization key and other necessary parameters.A quick example is as follows:fromtuya_connectorimport(TuyaOpenAPI,TuyaOpenPulsar,TuyaCloudPulsarTopic,)ACCESS_ID="your-access-id"ACCESS_KEY="your-access-key"API_ENDPOINT="https://openapi.tuyacn.com"MQ_ENDPOINT="wss://mqe.tuyacn.com:8285/"# Init OpenAPI and connectopenapi=TuyaOpenAPI(API_ENDPOINT,ACCESS_ID,ACCESS_KEY)openapi.connect()# Call any API from Tuyaresponse=openapi.get("/v1.0/statistics-datas-survey",dict())# Init Message Queueopen_pulsar=TuyaOpenPulsar(ACCESS_ID,ACCESS_KEY,MQ_ENDPOINT,TuyaCloudPulsarTopic.PROD)# Add Message Queue listeneropen_pulsar.add_message_listener(lambdamsg:print(f"---\nexample receive:{msg}"))# Start Message Queueopen_pulsar.start()input()# Stop Message Queueopen_pulsar.stop()OpenAPI referenceTuya opens up a variety of APIs covering scenarios such as device pairing, asset management, and device control. You can call APIs according toAPI referenceto create IoT applications.FeedbackIf you have any questions, please provide feedback viaGithub IssueorTechnical Ticket.LicenseThetuya-connector-pythonSDK is available under the MIT license. For more information, see theLICENSEfile.
Package: tuya-device-sharing-sdk
Tuya Device Sharing SDKA Python sdk for Tuya Open API, which provides basic IoT capabilities like device management capabilities, helping you create IoT solutions.
With diversified devices and industries, Tuya IoT Development Platform opens basic IoT capabilities like device management, AI scenarios, and data analytics services, as well as industry capabilities, helping you create IoT solutions.FeaturesAPIsManagerupdate_device_cacherefresh_mqsend_commandsget_device_stream_allocatequery_scenestrigger_sceneadd_device_listenerremove_device_listenerunloadCustomerApigetpostputdeleteSharingMQstartstopadd_message_listenerremove_message_listenerDeviceRepositoryquery_devices_by_homequery_devices_by_idssend_commandsHomeRepositoryquery_homesSceneRepositoryquery_scenestrigger_scenePossible scenariosSmart Life IntegrationUsageRelease NoteversionDescription0.1.8fix topic error0.1.9fix mq link id0.2.0MQTT bulk subscriptionInstallationpip3 install tuya-device-sharing-sdkIssue feedbackYou can provide feedback on your issue viaGithub Issue.Licensetuya-device-sharing-sdkis available under the MIT license. Please see theLICENSEfile for more info.main
Package: tuyagateway
We've made a library that communicates locally with your Tuya devices (no internet connection needed), calledTuyaFace. The library is open-source and can be used in your own software if you choose to do so. But we did the heavylifting already for you. TuyaGateway implements the library and communitates over an open protocol (MQTT) with your home automation software. All relevant home automation software packages (e.g. Home Assistant) are able to work with MQTT.Great! But what about GismoCaster?GismoCasteris the control-center for TuyaGateway. In a webinterface you can add your devices, set names for them, etc. So, no programming required and no dabbling around in obscure text files which will break when you add a tab to many.A bit more technicalTuyaGateway listens on MQTT topics and routes requests to your Tuya devices. In earlier versions the configuration was based on a one to one topic translation in e.g. Home-Assistant config-files. 1:1 topic translation is limited to simple tasks (like switching ON/OFF); only boolean values.From v1.1 onwards Tuya device configuration can be done withGismoCaster. In which you can set discovery messages for both TuyaGateway and Home Assistant and opens up the ability to set boolean/integer/float/string types.The goal for version v2.0 is to add input/output processing functions and to improve on HA message values. Next to structural improvements to the code. The topic configuration option will be removed.Docshttps://github.com/TradeFace/tuyagateway/wikiGet involved!Anyone who is willing to test, write code, add documentation, etc. is welcome to make acontribution.Acknowledgementshttps://github.com/emontnemerydevelopment tuyaclient and implementation in tuyagatewayhttps://github.com/jkerdreux-imttesting tuyaclienthttps://github.com/SDNick484testing protocol 3.1 reimplementation
Package: tuyaha
tuyahaCloned from the abandoned packagetuyapyv0.1.3. This package implements a Tuya
API endpoint that was specially designed for Home Assistant.This clone contains several critical fixes. Check commits.FAQHow to check whether the API this library using can control your device?Copythis scriptto your PC with Python
installed or tohttps://repl.it/Set/update config inside and run itCheck if your devices are listedIf they are and description matches real device (e.g. lamp is lamp, not switch) - device is supportedIf they are not or description doesn't match real device - don't open an issue. AskTuya supportto support your device in their/homeassistantAPIRemove the updated script, so your credentials won't leakMy device is not listed in Tuya API response or contains incomplete state, what should I do?Write an email totuyasmart@tuya.comand mention thetuyapylibrary andhttps://px1.tuya{}.comAPI endpoint. Usually they ignore incoming emails, but perhaps, if they get a lot of emails, they will start fixing the API.
Package: tuya-iot-py-sdk
Tuya IoT Python SDKA Python sdk for Tuya Open API, which provides basic IoT capabilities like device management, asset management and industry capabilities, helping you create IoT solutions.
With diversified devices and industries, Tuya Cloud Development Platform opens basic IoT capabilities like device management, AI scenarios, and data analytics services, as well as industry capabilities, helping you create IoT solutions.FeaturesBase APIsTuyaOpenAPIconnectis_connectgetpostputdeleteTuyaOpenMQstartstopadd_message_listenerremove_message_listenerAPIsTuyaDeviceListenerupdate_deviceadd_deviceremove_deviceDevice controlTuyaDeviceManagerupdate_device_list_in_smart_homeupdate_device_cachesupdate_device_function_cacheadd_device_listenerremove_device_listenerget_device_infoget_device_list_inforemove_deviceremove_device_listget_factory_infofactory_resetget_device_statusget_device_list_statusget_device_functionsget_category_functionsget_device_specificationsend_commandsHomeTuyaHomeManagerupdate_device_cachequery_scenestrigger_scenequery_infrared_devicestrigger_infrared_commandsAssetsTuyaAssetManagerget_device_listget_asset_infoget_asset_listPossible scenariosHomeAssistant Tuya PluginTuya Connector PythonFHEM Tuya Plugin by fhempy...PrerequisiteRegistrationPlease checkTuya IoT Platform Configuration Guideto register an account on theTuya IoT Platform, and get the required information. You need to create a Cloud project and complete the configuration of asset, user, and application. Then, you will get theusername,password,Access ID, andAccess Secret.UsageInstallationpip3 install tuya-iot-py-sdkSample codeOpenAPI SampleOpen IoT Hub SampleTuya Open API referenceTuya opens up a variety of APIs covering business scenarios such as device pairing, smart home management, device control, and scene automation. You can call APIs according to API integration documents to implement applications.For more information, see thedocumentation.Issue feedbackYou can provide feedback on your issue viaGithub IssueorTechnical Ticket.Licensetuya-iot-py-sdk is available under the MIT license. Please see theLICENSEfile for more info.
Package: tuyalinksdk
TuyaOS Link SDK for PythonTuyaOS Link SDK for PythonMinimum RequirementsInstall from PyPIInstall from sourceExamplesLicenseMinimum RequirementsPython 3.6+Install from PyPIpython3 -m pip install tuyalinksdkInstall from sourcegit clone https://github.com/tuya/tuyaos-link-sdk-python.git
python3 -m pip install ./tuyaos-link-sdk-pythonExamplesExamples READMEfromtuyalinksdk.clientimportTuyaClientclient=TuyaClient(productid='PID',uuid='UUID',authkey='AUTHKEY')defon_connected():print('Connected.')defon_dps(dps):print('DataPoints:',dps)client.push_dps(dps)client.on_connected=on_connectedclient.on_dps=on_dpsclient.connect()client.loop_start()LicenseThis library is licensed under the MIT License.
Package: tuyamqtt
Listens on MQTT topic and routes requests to Tuya devices, based on a one to one topic translation in e.g. Home-Assistant config-files. 1:1 topic translation is limited to simple tasks (like switching ON/OFF); only boolean values.TuyaMQTT usesTuyaFaceto communicate locally (no cloud connection needed) with your tuya devices.In v1.1 Tuya device configuration can be done withGismoCaster. In which you can set discovery messages for both TuyaMQTT and Home Assistant and opens up the ability to set boolean/integer/float/string types.The goal for version v1.2 is to add input/output processing functions and to improve on HA message values.Docshttps://github.com/TradeFace/tuyamqtt/wikiGet involved!Anyone who is willing to test, write code, add documentation, etc. is welcome to make acontribution.Acknowledgementshttps://github.com/emontnemerydevelopment tuyaclient and implementation in tuyamqtthttps://github.com/jkerdreux-imttesting tuyaclienthttps://github.com/SDNick484testing protocol 3.1 reimplementation
Package: tuyapower2mqtt
TuyaPower2MQTT - PyPi ModuleAuthor: Phill Healeyhttps://github.com/codeclinic/TuyaPower2MQTTDescriptionPython module to pull power and state data from Tuya / Smart Life / Jinvoo WiFi smart socket/switch devices.Tested on RaspberryPi, Linux, Windows 10 and MacOS.Compatible with Home Assistant.PreparationAll python dependencies for TuyaPower2MQTT will be automatically installed. However, you may need to installpython-cryptovia apt/yum/etc. If this is your first pip package then you may also need to installpython-pip.sudoapt-getinstallpython-cryptopython-pipYou'll need a Mosquitto (MQTT) server to publish the data to. If you don't already have one running, I recommend following this simple tutorial:Installing an MQTT server on Debian. Note, you can try installing MQTT without adding the repo suggested in the first step.FunctionsdeviceInfo - Poll device and return on, w, mA, V and err data.tuyapower.deviceInfo(PLUGID,PLUGIP,PLUGKEY,PLUGVERS)UsageGathers full power stats / data from Tuya sockets & switches and reports results as JSON via MQTTFull details coming soon.Home Assistant IntegrationI wrote an in-depth guide on how to use this package and how to extend it toHome Assistant integration
Package: tuyasmartapi
Copyright (c) 2019 Dr. Shubham DiptPermission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the “Software”), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.Description: # tuyasmartapiAn api for handling Tuya Smart devices.## Dependencies
Python3pip install -r requirements.txt## UsageCreate a config.ini file with the following contents.[TUYA]
username = <username>
password = <password>
location = EU
device = <device_id>## Installationpip install tuyasmartapi### Example>>>from tuya.devices import TuyaSmartSwitch
>>>device = TuyaSmartSwitch(username=CONFIG[“TUYA”][“username”], password=CONFIG[“TUYA”][“password”], location=CONFIG[“TUYA”][“location”], device=CONFIG[“TUYA”][“device”])
>>>print(device.get_status())Platform: any
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Description-Content-Type: text/markdown
Package: tuyau
TuyauTuyau is a library that allows you to process values through a sequence of steps, similar to a pipe.# Beforefornameinnames:len(hash(upper_case(decode(name))))# Aftertube=Tube(decode,upper_case,hash,len)fornameinnames:tube(name)# or alternativetube.send(name)InstallationYou can install Tuyau using pip:pipinstalltuyauUsageCreating a TuyauTo create a Tuyau, you can pass a sequence of callable steps to the constructor. Each step should be a callable that takes one argument and returns a value of any type.fromtuyauimportTubedefadd_one(number:int)->int:"""Simple step: add one to the number."""returnnumber+1defmultiply_by_two(number:int)->int:"""Simple step: multiply the number by two."""returnnumber*2tube=Tube(add_one,multiply_by_two)print(tube.send(1))# 4Processing ValuesYou can process values through the Tuyau by calling it as if it were a function. The value will go through each step in the sequence and get transformed accordingly.result=tube(5)print(result)# Output: 12 (5 + 1 = 6, 6 * 2 = 12)You can also use thesend()method, which is an alias for calling the Tuyau directly.result=tube.send(5)print(result)# Output: 12ExampleHere's an example using lambda functions as steps:tube=Tube(lambdax:x+1,lambdax:x*2)result=tube(3)print(result)# Output: 8 (3 + 1 = 4, 4 * 2 = 8)TypingTypingTheTubeclass is designed to support typing for both input and output.fromtuyauimportTubedefadd_one(num:int)->int:returnnum+1defmultiply_by_two(num:int)->int:returnnum*2# Create Tube with multiple callables that take and return inttube:Tube[int,int]=Tube(add_one,multiply_by_two)tube:Tube[int,str]=Tube(add_one,multiply_by_two,str)# Process integers through the tubesresult:int=tube(3)# Output: 6 (3 + 1 * 2)result2:str=tube(3)# Output: "6" str(3 + 1 * 2)ContributingContributions are welcome! If you find a bug or have a suggestion for improvement, please create an issue or a pull request onGitHub.Local devinstall .venv with all dev depmake dev-installlaunch testsmake testlaunch lintersmake lintLicenseThis library is licensed under the MIT License - see theLICENSEfile for details.