Saravanan666/pypi-org huggingface dataset:
Package: telemetrix-aio
The Telemetrix ProjectThe Telemetrix Project is a modern-day replacement for
Arduino StandardFirmata, equipped with many more built-in features than
StandardFirmata.Here is a feature comparison between Telemetrix and StandardFirmata:FeatureTelemetrixStandardFirmataAnalog InputXXAnalog Output (PWM)XXDigital InputXXDigital OutputXXi2c PrimitivesXXServo Motor ControlXXDHT Temperature/Humidity SensorXOneWire PrimitivesXHC-SR04 Sonar Distance SensorXSPI PrimitivesXStepper Motor Control (AccelStepper)XPython Threaded Client IncludedXPython Asyncio Client IncludedXSupport For STM32 Boards (Black Pill)XDesigned To Be User ExtensibleXIntegrated Debugging Aids ProvidedXExamples For All FeaturesXThe project consists of aPython client APIused to create a Python
client
application and C++ servers that communicate with the Python client over a serial or WiFi link.This repository is the Python 3 asyncio client API.The server for Arduino serial linked devices is calledTelemetrix4Arduino.The WiFi server for ESP8266 devices is calledTelemetrix4Esp8266.AUser's Guideexplaining installation and use is available online.
Package: telemetrix-extensions
Telemetrix i2c ExtensionsThis repository contains i2c extension libraries for theTelemetrixproject.To install using pypi, make sure that you have pip installed on your computer and for
Linux and Mac type:sudopip3installtelemetrix-extensionsFor Windows type:pipinstalltelemetrix-extensionsYou can read about i2c supporthere.Each library consists of two classes, one to handle non-asyncio applications and the
other to support asyncio applications.There are no changes required on the Telemetrix servers.Because the Telemetrix i2c API is consistent across all Telemetrix clients, to convert an
application from one hardware platform to another, only one or two lines need to be
modified.For example, to convert the telemetrix_pca.py example to run on an ESP8266, only the
Telemetrix client instantiation line needed to be modifiedFrom:# create a telemetrix instancethe_board=telemetrix.Telemetrix()To:# create a telemetrix instance# Change the ip address to match the ip address of your nodemcuthe_board=telemetrix.Telemetrix(ip_address='192.168.2.170')Both asyncio and non-asyncio library classes are available.Currently supported devices:PCA9685 Servo Driver
Package: telemetrix-nano-2040-wifi
Telemetrix-Nano-2040-WiFiTelemetrix-Nano-2040-WiFi is a member of theTelemetrixfamily and is a Python client
specifically tailored to remotely control and monitor
an Arduino Nano RP2040 Connect using Python scripts running on your PC.When paired with theTelemetrix4Connect2040custom Arduino server sketch, control and
monitoring of the Arduino Nano RP2040 Connect is accomplished using a Wi-Fi link
between the
PC and the Arduino.This library supports the following features:Analog and Digital InputDigital Outputs including PWMOnboard devices:IMUMicrophoneRGB LEDI2C device communications.SPI device communications.HC-SR04 Type distance sensors.DHT Type humidity/temperature sensors.Servo motors.NeoPixel strips.AUser's Guideexplaining installation and use is available online.The Python API for may be foundhere.Here is a sample project that blinks the Arduino Board LED:import sys
import time

from tmx_nano2040_wifi import tmx_nano2040_wifi

"""
Blink the board LED.
"""

# some globals
DIGITAL_PIN = 13  # the board LED

# Create a Telemetrix instance.
board = tmx_nano2040_wifi.TmxNano2040Wifi(ip_address='192.168.2.246')

# Set the DIGITAL_PIN as an output pin
board.set_pin_mode_digital_output(DIGITAL_PIN)

# Blink the Board LED
for blink in range(3):
    # When hitting control-c to end the program
    # in this loop, we are likely to get a KeyboardInterrupt
    # exception. Catch the exception and exit gracefully.
    try:
        print('1')
        board.digital_write(DIGITAL_PIN, 1)
        time.sleep(1)
        print('0')
        board.digital_write(DIGITAL_PIN, 0)
        time.sleep(1)
    except KeyboardInterrupt:
        board.shutdown()
        sys.exit(0)
board.shutdown()
sys.exit(0)
Package: telemetrix-rpi-pico
Telemetrix-RPi-PicoInteract and monitor  a Raspberry  Pi Pico remotely  from your PC using Python.
It is similar to Arduino Firmata, but written specifically for the Raspberry Pi
Pico.A full User's Guide isavailable online.Python API documentation  may be foundhere.The Pico server code may be viewedhere.The following functionality is implemented in this release:Analog InputDigital Input, Digital Input Pullup, Digital Input PulldownPWM outputLoopback (for client/server link debugging)I2C SupportSPI SupportNeoPixel SupportServo SupportHC-SR04 Type Sonar Distance Sensor SupportDHT 11 and 22 Humidity/Temperature Sensor SupportAutodetect PICO device over USB Serial.Automatic board reset of the PICO using the watchdog timer when application exits.Board will blink twice upon reset.Retrieval of the PICO's unique ID.To install The Client Library:Linux/macOS:sudopip3installtelemetrix-rpi-picoWindows:pipinstalltelemetrix-rpi-picoIf you are upgrading from a previously installed version:Linux/macOS:sudopip3installtelemetrix-rpi-pico--upgradeWindows:pipinstalltelemetrix-rpi-pico--upgradeTo Install The Pico Server ApplicationDownloadand save the .uf2 file.Place the Pico in file upload mode:A. Press and hold the BOOTSEL button while applying power.B. Release the BOOTSEL button.C. In your file explorer, you should see a new folder appear called: RPI-RP2.D. Drag the .uf2 file into this folder to upload the code.Download And Run The ExamplesDownload,save, and uncompress the teletmetrix-rpi-pico Github repository.Open theexamplesdirectory and run any of the examples. You may
modify them to suit your needs.
Package: telemetrix-rpi-pico-w
telemetrix-rpi-pico-wInteract and monitor a Raspberry Pi Pico W remotely from your PC using Python.
It is similar to Arduino Firmata but explicitly written for the Raspberry Pi Pico W.You have a choice of two client APIs. One usesPython threadingfor concurrency, and the
other usesPython asyncio.A complete User's Guide isavailable online.The Pico W server code is available to be viewedhere.The following functionality is implemented in this release:Analog InputDigital Input, Digital Input Pullup, Digital Input PulldownPWM outputLoopback (for client/server link debugging)I2C SupportSPI SupportNeoPixel SupportServo SupportHC-SR04 Type Sonar Distance Sensor SupportStepper Motor SupportDHT 11 and 22 Humidity/Temperature Sensor SupportAutomatic board reset of the PICO W using the watchdog timer when an
application exits.To install The Client Library:pipinstalltelemetrix-rpi-pico-wIf you are upgrading from a previously installed version:pipinstalltelemetrix-rpi-pico-w--upgradeTo Install The Pico-W Server ApplicationFollow the instructions in theUser's Guide.Download And Run The ExamplesDownload,save, and uncompress the telemetrix-rpi-pico-w Github repository. There is a directory
forthreaded examplesas well asasyncio examples.Open theexamplesdirectory and run any of the examples using Python3. You may
modify them to suit your needs.
Package: telemetrix-uno-r4
telemetrix-uno-r4Telemetrix For The Arduino UNO R4 Minima and WIFIThis Python package allows you to monitor and control an UNO R4 Minima or
WIFI board by simply writing a Python script using one of the telemetrix--uno-r4 APIs.
APIs are provided for both synchronous and asyncio implementations.FeatureMinimaWIFINotesAnalog InputXXAnalog Output (PWM)XXDigital InputXXDigital OutputXXi2c PrimitivesXXServo Motor ControlXXDHT Temperature/Humidity SensorXXHC-SR04 Sonar Distance SensorXXSPI PrimitivesXXScrolling Message SupportXIntegrated Debugging Aids ProvidedXXExamples ProvidedFor All FeaturesXXFor the Minima, communication with the Python client is supported by a USBSerial
transport.For the WIFI board, you may choose a WIFI, USBSerial or BLE transport. The transport
type is identified on the LED display.Please refer to theUser's Guidefor further information, including installation
instructions and client APIs.Programmed withPycharm
Package: telemetron-client
# README #A Python client for Telemetron.## DependenciesPython 2.6+urllib3certifi## How to use the client### Sending a counter using _UDP_, to localhost:2013:from telemetronclient.telemetronclient import TelemetronClient as Clientclient = Client(settings={'app': "myapp",'prefix': "foo",'transport': Client.TRANSPORT_UDP,'host': '127.0.0.1','port': 2013})client.counter("mycounter", 1000)client.flush()### Sending a counter using _API_, to _metrics.external.com:443_, with 2 seconds timeout:from telemetronclient.telemetronclient import TelemetronClient as Clientclient = Client(settings={'host': "metrics.external.com",'port': 443,'transport': Client.TRANSPORT_API_SSL,'token': "2783c376-6c04-11e5-8941-e78df619a7cd",'app': "myapp",'prefix': "foo",'timeout': 2.0})client.counter("mycounter", 1000)client.flush()## How to run testspylint --rcfile pylint.rc telemetronclient/pylint --rcfile pylint.rc tests/pep8 telemetronclient/pep8 tests/nosetests## Deployment instructions### Using package:python setup.py install### Using pip:pip install telemetron-client
Package: telemetry
Remote measuring abstraction for software applications.telemetryserves as a simple facade or abstraction for various telemetry frameworks (e.g. pagerduty, slack, graphite)
allowing the end user to plug in the desired telemetry framework at deployment time. Thinkslf4jbut for events and numbers.  This library borrows from their example (and copy.)As your projects grow, their telemetry requirements will change.  The purpose of this library is to simplify
implementation, provide easy configuration, encourage testing, and avoid vendor lock.Supported Services:pagerdutyslackstatsd, graphite, datadogTelemeters preference to being configurable, but don't require more than
credentials to get working. For instance, slack can be implemented with
the following:import logging
from telemetry import SlackTelemeter

logging.basicConfig(level=logging.INFO)
logging.getLogger().addHandler(SlackTelemeter())
logging.info("hello room!")orfrom telemetry import SlackTelemeter
meter = SlackTelemeter()
meter.message("your message!")Clients are written using core python libraries, sotelemetryis light weight.
Package: telemetry-datastore
Telemetry Data StoreThe telemetry data store allows store, aggregate and retrieve telemetry data for your IoT project
using simple API call that will hide all the complexity from the user.No file system manipulation is necessary and several databases can be created to separate different contexts if necessary.Once the telemetry is inserted into the database, an aggregation process is executed automatically.The raw data (the one inserted by the user) and the aggregated data is immediately available.The library performs the following aggregations:SumAverageCountMaximum andMinimumData is aggregated over the hour, day, month and year.Use casesPermanent telemetry storageData manipulation at the edge
Package: telemetry-email-alerter
Python script that allows you to subscribe to Arista Telemetry events and then send them to an SMTP server for email notifications.Emails are sent for events that occur while the alerter is running—you won’t get alerts for past events.We recommend you set up email filters to limit notifications. For example, you can set up filters to ignore “INFO” events based on the email subject.InstallationPython 2.7 andpipare required.You can download the alerter viapipby runningpip installtelemetry-email-alerter.UsageYou can start up the alerter by running:telemetry-email-alerter <telemetry-server> <smtp-server> <email-1> <email-2> ... <email-n>The full list of arguments accepted by the script are listed below.NameRequired?DefaultDescriptiontelemetryUrlyes—The IP address
or hostname of
your CVP
Telemetry
instancesmtpServeryes—The IP address
or hostname of
your SMTP
(email) serversendToAddressyes—The emails to
send
notifications
to. You can
specify
multiple emails–sendCcAddressa@example.comb@example.comno—Emails to CC
notifications
for. You can
specify
multiple emails–port 1234no465The port your
SMTP server
listens to if
it use a
non-standard
port–subjectPrefix
‘CVP Alert’no[CloudVision
Telemetry]A message to
prepend to
email subjects–noSmtpSslnooff (SSL is
used)Disable SSL for
SMTP
connections–smtpUsernamea@example.comno—SMTP server
username if
authentication
is required–smtpPassword
secretno—SMTP server
password if
authentication
is required.
You will be
prompted at
startup if this
is not provided–noTelemetrySslnooff (SSL is
used)Disable SSL for
Telemetry
connections–telemetryUsername
exampleno—Telemetry
username if
authentication
is required–telemetryPassword
secretno—Telemetry
password if
authentication
is required.
You will be
prompted at
startup if this
is not provided–noSslValidationnooff (validation
is used)Disables
validation of
SSL
certificates.
For debugging
purposes. Not
advised to use
in real
environments–verbosenooffShow logging
messagesUsing an SMTP serverWe recommend you use an SMTP server you run and maintain yourself. Your company might have one you can use.Alternatively you can usethe Gmail SMTP server. You can use your Gmail username andan app password. Be aware of its send limits though—it’s certainly possible you might exceed them.Development infoYou will need Python 2.7 withpipandvirtualenv. You can read more about these inthe Python packaging documentation. Create avirtualenvto house the dependencies of this project. Once that’s done, you can install dependencies by runningpip install-rrequirements.pipfrom the project root.You can test email notifications by using the Gmail SMTP server mentioned inUsing an SMTP server. Alternatively you can use an app likemailslurperon your machine locally.To run the script locally, you can run thetelemetry_email_alerterpackage from the project root:python telemetry_email_alerter [...args]
Package: telemetry-parser
telemetry-parser-pyLibrary to parse real-time metadata embedded in video files or telemetry from other sources.Supported formats:GoPro (HERO 5 and later)Sony (a1, a7c, a7r IV, a7 IV, a7s III, a9 II, FX3, FX6, FX9, RX0 II, RX100 VII, ZV1, ZV-E10)Insta360 (OneR, OneRS, SMO 4k, Go, GO2, Caddx Peanut)DJI (Avata, O3 Air Unit, Action 2)Blackmagic RAW (*.braw)RED RAW (V-Raptor, KOMODO) (*.r3d)Betaflight blackbox (*.bfl, *.bbl, *.csv)ArduPilot logs (*.bin, *.log)Gyroflow.gcsv logiOS apps:Sensor Logger,G-Field Recorder,Gyro,GyroCamAndroid apps:Sensor Logger,Sensor Record,OpenCamera Sensors,MotionCam ProRuncam CSV (Runcam 5 Orange, iFlight GOCam GR, Runcam Thumb, Mobius Maxi 4K)Hawkeye Firefly X Lite CSVXTU (S2Pro, S3Pro)WitMotion (WT901SDCL binary and *.txt)Vuze (VuzeXR)KanDao (Obisidian Pro)CAMM formatTODO DJI flight logs (*.dat, *.txt)Example usage:importtelemetry_parsertp=telemetry_parser.Parser('sample.mp4')print('Camera: ',tp.camera)print('Model: ',tp.model)# return all telemetry as an array of dictsprint('Telemetry',tp.telemetry())# format the values with units etcprint('Telemetry formatted',tp.telemetry(human_readable=True))# return only gyro and accel with timestamps, normalized to a single orientation and scaled to deg/s and m/s2print('Normalized IMU',tp.normalized_imu())BuildingSetup virtual env:python -m venv .env ; source .env/bin/activateInstall maturin:pip install maturinBuild python wheels:maturin build --releaseResulting wheels will be intarget/wheels/directoryInstall using pip:pip install telemetry_parser_py-0.1.0-cp39-none-win_amd64.whl
Package: telemetry-producer
telemetry_producerA JupyterLab extension.This extension is composed of a Python package namedtelemetry_producerfor the server extension and a NPM package namedtelemetry-producerfor the frontend extension.RequirementsJupyterLab >= 4.0.0InstallTo install the extension, execute:pipinstalltelemetry_producerUninstallTo remove the extension, execute:pipuninstalltelemetry_producerTroubleshootIf you are seeing the frontend extension, but it is not working, check
that the server extension is enabled:jupyterserverextensionlistIf the server extension is installed and enabled, but you are not seeing
the frontend extension, check the frontend extension is installed:jupyterlabextensionlistContributingDevelopment installNote: You will need NodeJS to build the extension package.Thejlpmcommand is JupyterLab's pinned version ofyarnthat is installed with JupyterLab. You may useyarnornpmin lieu ofjlpmbelow.# Clone the repo to your local environment# Change directory to the telemetry_producer directory# Install package in development modepipinstall-e"."# Link your development version of the extension with JupyterLabjupyterlabextensiondevelop.--overwrite# Server extension must be manually installed in develop modejupyterserverextensionenabletelemetry_producer# Rebuild extension Typescript source after making changesjlpmbuildYou can watch the source directory and run JupyterLab at the same time in different terminals to watch for changes in the extension's source and automatically rebuild the extension.# Watch the source directory in one terminal, automatically rebuilding when neededjlpmwatch# Run JupyterLab in another terminaljupyterlabWith the watch command running, every saved change will immediately be built locally and available in your running JupyterLab. Refresh JupyterLab to load the change in your browser (you may need to wait several seconds for the extension to be rebuilt).By default, thejlpm buildcommand generates the source maps for this extension to make it easier to debug using the browser dev tools. To also generate source maps for the JupyterLab core extensions, you can run the following command:jupyterlabbuild--minimize=FalseDevelopment uninstall# Server extension must be manually disabled in develop modejupyterserverextensiondisabletelemetry_producer
pipuninstalltelemetry_producerIn development mode, you will also need to remove the symlink created byjupyter labextension developcommand. To find its location, you can runjupyter labextension listto figure out where thelabextensionsfolder is located. Then you can remove the symlink namedtelemetry-producerwithin that folder.Packaging the extensionSeeRELEASE
Package: telemetry-router
telemetry_routerA JupyterLab extension.This extension is composed of a Python package namedtelemetry_routerfor the server extension and a NPM package namedtelemetry-routerfor the frontend extension.RequirementsJupyterLab >= 4.0.0InstallTo install the extension, execute:pipinstalltelemetry_routerUninstallTo remove the extension, execute:pipuninstalltelemetry_routerTroubleshootIf you are seeing the frontend extension, but it is not working, check
that the server extension is enabled:jupyterserverextensionlistIf the server extension is installed and enabled, but you are not seeing
the frontend extension, check the frontend extension is installed:jupyterlabextensionlistContributingDevelopment installNote: You will need NodeJS to build the extension package.Thejlpmcommand is JupyterLab's pinned version ofyarnthat is installed with JupyterLab. You may useyarnornpmin lieu ofjlpmbelow.# Clone the repo to your local environment# Change directory to the telemetry_router directory# Install package in development modepipinstall-e"."# Link your development version of the extension with JupyterLabjupyterlabextensiondevelop.--overwrite# Server extension must be manually installed in develop modejupyterserverextensionenabletelemetry_router# Rebuild extension Typescript source after making changesjlpmbuildYou can watch the source directory and run JupyterLab at the same time in different terminals to watch for changes in the extension's source and automatically rebuild the extension.# Watch the source directory in one terminal, automatically rebuilding when neededjlpmwatch# Run JupyterLab in another terminaljupyterlabWith the watch command running, every saved change will immediately be built locally and available in your running JupyterLab. Refresh JupyterLab to load the change in your browser (you may need to wait several seconds for the extension to be rebuilt).By default, thejlpm buildcommand generates the source maps for this extension to make it easier to debug using the browser dev tools. To also generate source maps for the JupyterLab core extensions, you can run the following command:jupyterlabbuild--minimize=FalseDevelopment uninstall# Server extension must be manually disabled in develop modejupyterserverextensiondisabletelemetry_router
pipuninstalltelemetry_routerIn development mode, you will also need to remove the symlink created byjupyter labextension developcommand. To find its location, you can runjupyter labextension listto figure out where thelabextensionsfolder is located. Then you can remove the symlink namedtelemetry-routerwithin that folder.Packaging the extensionSeeRELEASE
Package: telemetry-tempest-plugin
Tempest plugin for Telemetry Project.It contains tempest tests for Aodh, Ceilometer, and Gnocchi Projects.Free software: Apache licenseDocumentation:https://docs.openstack.org/ceilometer/latest/Source:https://opendev.org/openstack/telemetry-tempest-pluginBugs:https://bugs.launchpad.net/ceilometer
Package: tele-mod
Installingpip3install-Utele-modTelemodMessage listener exampleimportasynciofromtelebotimportasync_telebot,typesfromtelemodimportListenerbot=async_telebot.AsyncTeleBot(token="")loop=asyncio.get_event_loop()listener=Listener(bot=bot,loop=loop)@bot.message_handler(commands=["start"])asyncdef_(message:types.Message):msg=awaitlistener.listen_to(m=message,text="What's Your name?")awaitbot.reply_to(msg,f"Your name is{msg.text}")# to delete question message# await bot.delete_message(chat_id=message.chat.id, message_id=msg.output.id)asyncdefmain():print((awaitbot.get_me()).first_name)awaitbot.infinity_polling(skip_pending=True)loop.run_until_complete(main())CallbackQuery Listener Example@bot.callback_query_handler(func=lambdaquery:True)asyncdef_(query:types.CallbackQuery):ifquery.data=="name":msg=awaitlistener.listen_to(query,"What's your name?",filters=["text"])returnawaitbot.reply_to(msg,f"Your name is{msg.text}")Simple usage examplemsg=awaitlistener.listen(chat_id=chat_id,text="What's your name",from_id=from_id,filters=["text","photo"])print(msg)Time out example@bot.message_handler(commands=["start"])asyncdefstart_handler(message:types.Message):try:msg=awaitlistener.listen_to(message,"What's your name?",timeout=10)exceptTimeOut:msg=Noneawaitbot.reply_to(message,"Time Out")ifmsg:returnawaitbot.reply_to(msg,f"Hi{msg.text}")Filters type example@bot.message_handler(commands=["ask"],chat_types=["supergroup"])asyncdef_(message:types.Message):msg=awaitlistener.listen(chat_id=message.chat.id,text="What's your name",filters=["sender_chat","text"],filters_type=2)# will only listen to an message has "sender_chat" and "text" attributemsg=awaitlistener.listen(chat_id=message.chat.id,text="What's your name",filters=["sender_chat","text"],filters_type=1)# will listen to any messgae has "sender_chat" or "text" attributereturnawaitbot.reply_to(msg,msg.text)CommunityJoin To Our Channel:https://t.me/Y88F8Exampleshttps://github.com/x72x/tele-mod/tree/main/examples
Package: telemongo
Telethon MongoDB SessionThis is aTelethonsession backend which uses MongoDB.Installingpip3 install telemongoUpgradingpip3 install -U telemongo mongoengineUsagefrommongoengineimportconnectfromtelemongoimportMongoSessionfromtelethonimportTelegramClientapi_id=12345api_hash="0123456789abcdef0123456789abcdef"host="mongo://username:pass@mongo_host/dbname"connect('dbname',host=host)session=MongoSession('dbname',host=host)client=TelegramClient(session,api_id,api_hash)client.start()