Saravanan666/pypi-org huggingface dataset:
Package: airthings
airthingsairthingsis a simple python package that contains methods to
communicate with Airthings[1] devices. The package utilizies bluepy[2]
for the communication between python and the devices. The package
features can be found below.[1]https://airthings.com/[2]https://github.com/IanHarvey/bluepyNote: Some features are currently undocumented, and parts are
untested/not yet implemented.FeaturesAutodiscover Airthings devicesFind and search for Airthings devices by using MAC addresses and/or
identifiersFetch sensor measurements from various Airthings models, see sensor
capability list belowRequirementsbluepyonly supports Linux, and is therefore currently the only
supported operating system. I have only tested with theWave Plus Gen 1 (2930). Other device models should in theory work
fine, but they are untested or might be unimplemented.System requirements:-  libglib2.0-dev

Installation
------------

The current stable version of airthings is available on pypi and can be
installed by running:

``pip install airthings``

Other sources:

-  pypi: http://pypi.python.org/pypi/airthings/
-  github: https://github.com/kotlarz/airthings/

Usage
-----

Examples can be found in the `examples <./examples>`__ directory.

Supported devices
-----------------

*Note: “Model number” are the first 4 digits of the Airthings device
serial number*

Wave Gen 1 (Model number: 2900)On 1st Gen Wave, temperature and humidity are updated every time we read
the wave.Sensor capabilities
^^^^^^^^^^^^^^^^^^^Humidity (%rH)Radon short term average (Bp/m3)Radon long term average (Bq/m3)Temperature (°C)Wave Mini Gen 1 (Model number: 2920)Sensor values are updated every 5 minutes.

.. _sensor-capabilities-1:

Sensor capabilities
^^^^^^^^^^^^^^^^^^^

-  Humidity (%rH)
-  Temperature (°C)
-  VOC (ppb)

Wave Plus Gen 1 (Model number: 2930)Except for the radon measurements, the Wave Plus updates its current
sensor values once every 5 minutes. Radon measurements are updated once
every hour... _sensor-capabilities-2:Sensor capabilities
^^^^^^^^^^^^^^^^^^^Humidity (%rH)Radon short term average (Bp/m3)Radon long term average (Bq/m3)Temperature (°C)Atmospheric pressure (hPa)CO2 (ppm)VOC (ppb)Wave Gen 2 (Model number: 2950)On 2nd Gen Wave, temperature and humidity are updated every 5 minutes.
On both devices, radon measurements are updated once every hour.

.. _sensor-capabilities-3:

Sensor capabilities
^^^^^^^^^^^^^^^^^^^

-  Humidity (%rH)
-  Radon short term average (Bp/m3)
-  Radon long term average (Bq/m3)
-  Temperature (°C)
Package: airthings-ble
airthings-bleLibrary to control Airthings devices through BLE, primarily meant to be used in
theHome Assistant integration.Getting StartedPrerequisites:Pythonwith version 3.11 that is required by Home Assistant (docs)PoetryInstall dependencies:poetryinstallRun tests:poetryrunpytestLicenseThis project is licensed under the MIT License. See theLICENSEfile for details.
Package: airthings-exporter
Airthings ExporterPrometheus exporter for Airthings devices.RequirementsPython 3Airthings deviceSetupRegister your Airthings device to sync with the cloud following the instructions manualCheck the Airthings app or theweb dashboardto obtain your device serial number. This is your client idGo to theAirthings Integrations webpageand request an API Client to obtain a client secretInstall airthings-exporterpipinstallairthings-exporterUsage# Start server (1 device)airthings-exporter--client-id[client_id]--client-secret[client_secret]--device-id[device_id]# Start server (2 devices)airthings-exporter--client-id[client_id]--client-secret[client_secret]--device-id[device_id_1]--device-id[device_id_2]# Test server workscurl-slocalhost:8000Tested DevicesAirthings View PlusAirthings Wave MiniExample Prometheus configuration file (prometheus.yml)scrape_configs:
  - job_name: 'airthings'
    scrape_interval: 5m
    scrape_timeout: 10s
    static_configs:
      - targets: ['localhost:8000']API limitationsAirthings API for consumers allows only up to 120 requests per hour. Every scrape in prometheus sends one request per device to the Airthings API. Make sure the configured prometheus scrape interval does not exceed the limit.
Package: airthingswave-mqtt
# Get Readings from an Airthings Wave and publish to MQTT server[Airthings](http://airthings.com) makes a BTLE Radon detector called "Wave". This is an executable intended to be called periodically from Cron or some other scheduler to publish readings to an MQTT server.## LimitationsThis application doesn't implement 'find' as provided in the example at https://airthings.com/raspberry-pi/## API```Pythonclass AirthingsWave:def __init__(self, config_file):```Class instantiation requires a path to a config file in YAML format.```mqtt:broker: 192.168.30.18port: 1883waves:- name: "basement-radon"addr: 98:07:2d:43:4d:ff```Before taking a reading, you should:```def ble_connect(self, addr):```Then you can:```def get_readings(self, p):def publish_readings(self, name, readings):```## ExampleFrom __main__.py:```pythonc = sys.argv[1]atw=airthingswave.AirthingsWave_mqtt(c)count=len(atw.waves)if count > 0:iter=0while iter<count:handle = atw.ble_connect(atw.waves[iter]["addr"])r = atw.get_readings(handle)atw.ble_disconnect(handle)atw.publish_readings(atw.waves[iter]["name"], r)iter = iter+1return True```
Package: airtight
If you’re going toimport antigravity, you’d better make sure the hatch is closed.Theairtightpackage is written for Python 3.6+. It provides idiosyncratic code that somewhat simplifies the creation and debugging of command-line python scripts.simpler than a templateInstead of copying some 50-line template for your python script and then writing a bunch of calls toargparseandloggingjust build some lists describing the arguments and logging level you want and invokeartight.cli.configure_commandline():#!/usr/bin/env python3# -*- coding: utf-8 -*-"""
Example script template using the airtight module
"""fromairtight.cliimportconfigure_commandlineimportloggingDEFAULT_LOG_LEVEL=logging.WARNINGOPTIONAL_ARGUMENTS=[# each argument is a list: short option, long option, default value,# help string, required?['-l','--loglevel','NOTSET','desired logging level ('+'case-insensitive string: DEBUG, INFO, WARNING, or ERROR',False],['-v','--verbose',False,'verbose output (logging level == INFO)',False],['-w','--veryverbose',False,'very verbose output (logging level == DEBUG)',False],['-x','--custom',7,'your custom argument',False]]POSITIONAL_ARGUMENTS=[# each argument is a list with 3 elements: name, type, help['foovar',str,'some input value that you want']]defmain(**kwargs):"""Main function of your script.

    kwargs -- keyword arguments as parsed from the command line
    """# your additional code hereif__name__=="__main__":main(**configure_commandline(OPTIONAL_ARGUMENTS,POSITIONAL_ARGUMENTS,DEFAULT_LOG_LEVEL))make debug logging just a wee bit easierTheairtight.loggingmodule provides two methods:configure_logging(), which is used byairtight.cli.configure_commandline(), andflog(), which reduces typing when you want to log a variable’s name and value.So, you can write:>fromairtight.loggingimportflog>fish='salmon'>flog(fish)DEBUG:foo_script:fish:'salmon'flog()logs to DEBUG by default, but an optional keyword argumentlevelmay be used to specify another standard level, e.g.:>fromairtight.loggingimportflog>importlogging>fish='salmon'>flog(fish,level=logging.WARNING)WARNING:foo_script:fish:'salmon'Another optional keyword argument (comment) may be specified. A string value supplied via this argument will be postfixed to the logged variable name and value, thus:>fromairtight.loggingimportflog>fish='salmon'>flog(fish,comment='I like this fish!')DEBUG:foo_script:fish:'salmon'Ilikethisfish!etc.Bug reports and feature requests are welcome, but really I’d prefer pull requests.tododocstrings
Package: airtiler
The airtiler generates training / test data for neural networks by
downloading buildings from vector data from OpenStreetMap and the
corresponding satellite images from Microsoft Bing Maps.It then generates binary masks from the vector data which can be used
for example for instance segmentation.ExamplesInstance SeparationImageMaskFalseTrueInstallationTo install airtiler run:pipinstallairtilerUsageairtiler -c sample_config.jsonAPIairtiler=Airtiler("bing_key")airtiler.process(config)ConfigKeyRequiredoptionsboundingboxesYesOptions (optional)KeyDescriptiontarget_dirThe directory where the files
will be written tozoom_levelsGlobal zoom levels which will be
used, if a boundingbox if
specified in short format or has
no boundingboxes.separate_instancesIf true, each building instance
will be separated. Otherwise, a
building consisting from multiple
instances will be rendered as
one.Sample config{"options":{"target_dir":"./output/blabla","zoom_levels":[15,16,17],"separate_instances":false},"query":{"tags":["highway","building","leisure=swimming_pool"]},"boundingboxes":{"firenze":[11.239844,43.765851,11.289969,43.790065],"rapperswil":{"zoom_levels":[17,18],"tr":8.818724,"tl":47.222126,"br":8.847435,"bl":47.234629},"new_york":{"tr":-74.02059,"tl":40.646089,"br":-73.864722,"bl":40.77413}}}ProjectsThe airtiler is used in the following projects:Deep OSM - Instance segmentation using orthophotos and OSM data
Package: airton-ac
airton-acControl an Airton AC device over LAN.
This requires having thewifi module.Featuresasynchronous methods and transportpersistent communication to the deviceautomatic remote device state updates (remotes can still be used)configurable buffering for subsequent updatesconstraints between device commandsDomoticz plugin using a dedicated threadUsageSeelocal tuya requirementsfirst to find device information.Example usage:fromlocal_tuyaimportDeviceConfig,ProtocolConfigfromairton_acimportACDevice,ACFanSpeedasyncwithACDevice(DeviceConfig(ProtocolConfig("{id}","{address}",b"{key}")))asdevice:awaitdevice.switch(True)awaitdevice.set_speed(ACFanSpeed.L2)awaitdevice.switch(False)Domoticz pluginThe plugin requires having fetched device information using instructions above.
Make sure to readplugin instructionsfirst.💡 The Domoticz version should be2022.1or higher.python-mpipinstall--upgradeairton-ac[domoticz]python-mairton_ac.domoticz.installDomoticz path defaults to~/domoticzbut you can pass a-poption to the second command to change that:python-mairton_ac.domoticz.install-p/some/other/pathRestart Domoticz and create a new Hardware usingTuya Airton AC. Fill in device information and add.
The hardware will create up to 5 devices to control the fan (all prefixed with hardware name):power: to turn on or offset point: to set the target temperaturetemperature: to record curent temperature as measured by the unitmode: to control operating modefan: to control fan speedeco: toggle low heat when heating and eco-mode when coolinglight: toggle display on the unitswing: toggle swing modesleep: toggle sleep modehealth: toggle health modeYou can customize the devices you want added in the hardware page.All device names and levels can be changed once added as only IDs are used internally.
Package: airtools
AIRtoolsLimited subset of P.C. Hansen and J. S. JørgensenAIRtools 1.0Matlab suite of inversion / regularization tools, along with some ReguTools functions.
Also includes linear constrained least squares solver using cvxopt inlsqlin.pyMore function are available in Matlab fromAIRtools 2.Installpython-mpipinstall-e.UsageJust paste the code from each test into your console for the function
you're interested in. Would you like to submit a pull request for an
inversion example making a cool plot?picard.py: Picard Plotkaczmarz.py  Kaczmarz ARTmaxent.py: Maximum Entropy Regularization  (from ReguTools)rzr.py: remove unused or little used rows from tomographic projection matrixlsqlin.py: linear constrained least squares solvermatlab/logmart.m:  Implementation of log-MARTfortran/logmart.f90: log-MART in FortranExamplestests/test_all.pyTestsRun a comparison of the Python code with the Matlab code in thematlabdirectory by:python airtools/tests/test_octave.pywhich runs the Matlab version viaOct2Py.
Package: airtouch2
airtouch2_pythonIn-development Python client for the Polyaire AirTouch 2 and 2+ airconditioning systems.Thanks tohttps://github.com/tonymyatt/airtouch3apihttps://github.com/ozczecho/vzduch-dotekhttps://community.home-assistant.io/t/polyaire-air-touch-2-or-3/19650/44
Package: airtouch4pyapi
Airtouch 4 & 5 Python TCP APIAn api allowing control of AC state (temperature, on/off, mode) of an Airtouch 4 controller locally over TCP.  Airtouch 5 support is experimental as of 28 Nov 2022, and is fully interface compatible with AT4.All you need to do is initialise and specify the correct AirTouchVersion (if you don't, it assumes 4).WarningI am using this with my own Airtouch 4 and see no issues. Please don't blame me if you have any issues with your Airtouch 4 or AC system after using this - I don't know much about AC systems and will probably not be able to help!Others are using it with Airtouch 5 and see no issues.UsageTo initialise:airTouch = AirTouch("192.168.1.19")airTouch = AirTouch("192.168.1.1", AirTouchVersion.AIRTOUCH5)As a test:Use the demo.py file and pass in an AirTouch IP.  It takes you through a few tests.NotesAirTouch5: If you turn off all zones, the AC itself turns off.  Turning on a zone does not turn the AC back on by itself.  You must turn it back on too.  Same behaviour in 'official' app.To load:await airTouch.UpdateInfo();-- This loads the config from the AirTouch.  Make sure you check for any errors before using it.  It will load the Group/Zone info, the AC info, then capabilities.  This needs to happen prior to using.The following functions are available:Group Level Functions:SetGroupToTemperature(async)TurnGroupOn(async)TurnGroupOff(async)SetCoolingModeByGroup(async)SetFanSpeedByGroup(async)GetSupportedCoolingModesByGroup-- Based on the loaded config.GetSupportedFanSpeedsByGroup-- Based on the loaded config.AC Level FunctionsTurnAcOn(async)TurnAcOff(async)SetFanSpeedForAc(async)SetCoolingModeForAc(async)GetSupportedCoolingModesForAcGetSupportedFanSpeedsForAcGetAcs
Package: airtrackrelay
airtrackrelayUDP socket server to collect live tracking reports and
relay them to metarace telegraph as JSON encoded objects.Supported tracking devices and messages:Quectel GL300/320 "Air Interface"+ACK : Command acknowledge, type: 'drdack'+RESP, +BUFF:GTFRI, GTRTL, GTSOS, GTLOC : Location report, type: 'drdpos'GTINF : Information report, type: 'drdstat'BeakerAES128 Location, type 'drdpos'Configuration is via metarace sysconf section 'airtrackrelay' with the
following keys:key(type) Description [default]topic(string) MQTT relay topic ['tracking/data']port(int) UDP listen port [1911]k1(string) Beaker K1, 128 bit hex string [null]k2(string) Beaker K2, 128 bit hex string [null]uid(int32) Beaker uid/config id [0x45670123]Tracker imeis are read from the section 'tracking' under the
key 'devices', which is a map of device ids to a dict object:key(type) Description [default]imei(string) Device IMEItype(string) Device typeExample config:{
 "airtrackrelay": {
  "port": 12345,
  "topic": "tracking/data",
      "key": "000102030405060708090a0b0c0d0e0f",
      "cbcsig": 1234567890
 },
 "tracking": {
  "devices": {
   "bob": { "imei": "012345678901234", "label": null,
    "phone": "+12345678901", "type": null },
   "gem": { "imei": "023456788901234", "label": null,
    "phone": null, "type": null },
  }
 }
}Example Info Message:{"type": "drdstat", "drd": "bob", "devstate": "41", "rssi": "13",
 "voltage": "4.08", "battery": "94", "charging": "0", "buffered": false,
 "sendtime": "20220101023424" }Example Ack Message:{"type": "drdack", "drd": "gem", "ctype": "GTFRI", "cid": "1A3D",
 "sendtime": "20220101031607", "req": ""}Example GL3xx Location Message:{"type": "drdpos", "fix": true, "lat": "-13.567891",
 "lng": "101.367815", "elev": "22.6", "speed": "12.7",
 "drd": "gem", "fixtime": "20220101022231",
 "buffered": false, "battery": "94", "flags": 0}Example Beaker Location Message:{"type": "drdpos", "fix": true, "lat": "-12.345666",
 "lng": "101.123555", "speed": "0.0", "drd": "bob",
 "fixtime": "2023-01-13T03:12:49.00Z", "battery": "100",
 "buffered": false, "flags": 255}Requirementsmetarace >=2.0Installation$ pip3 install airtrackrelay
Package: airtrik
Airtrik pythonAirtrik is an IoT Cloud platform for managing communication between IoT devices and software platforms.
This is python sdk that can be used for communicating to both IoT device running python as a programming language like Raspberry Pi
and software platform running python. This library can also be used for making realtime data pipeline for applying machine learning on the IoT devices.SummaryGetting StartedPrerequisitesInstallingConnecting to your App's NetworkSubscribe to device in App's NetworkSending message to deviceReceiving messages from deviceVersioningAuthorsLicenseGetting StartedFollow the below instructions to get your device and application up and running within minutes. It is very easy to integrate airtrik into your project.PrerequisitesBefore proceeding further you have the following software installed in your system or development system.python (Version > 3.5)
pip (any recent version)InstallingInstalling airtrik python library is straight forward, just install it with pip. Although it will work pretty well with your system python.
We recommend using the virtual environment for your projectpip install airtrikConnecting to your App's Networkimportairtrik.iotasiot# create app in the panel to get the app keyiot.connect("__APP_KEY__")Subscribe to device in App's Network# you have to create device inside app from paneldevice="__DEVICE_ID__"iot.subscribe(device)Sending message to devicemessage="YOUR MESSAGE TO DEVICE"iot.send(device,message)Receiving messages from device# you can write your custom function handling the incoming messagedefonReceive(deviceId,message):print(deviceId,message)iot.onReceive=onReceiveiot.waitForMessage()VersioningAuthorsVishal Pandey-Written Python Library-vishal-pandeySee also the list ofcontributorswho participated in this project.LicenseThis project is licensed under theMITCreative Commons License - see theLICENSEfile for
details
Package: airtunnel
Airtunnelis a means of supplementingApache Airflow, a platform for
workflow automation in Python which is angled at analytics/data
pipelining. It was born out of years of project experience in data
science, and the hardships of running large data platforms in real life
businesses. Hence, Airtunnel is both a set of principles (read more on
them in theAirtunnel introduction article) and a lightweight Python
libraryto tame your airflow!Why choose airtunnel?Because you will…❤️ …stop worrying and love the uncompromised consistency🚀 …need a clean codebase with separated concerns to be scalable📝 …get metadata for ingested files, load status and lineage
out-of-the-box🏃 …have it up and running in minutes🍺 …spend less time debugging Airflow DAGs doing worthwhile things
insteadGetting startedTo get started, we warmly recommended to read theAirtunnel introduction articleand theAirtunnel tutorial.
Also check out thedemo project.InstallationWe suppose you have installed Apache Airflow in some kind of Python virtual
environment. From there, simply do apip install airtunnelto get
the package.Configure your codebase according to the Airtunnel principles: You
need to add three folders for a declaration store, a scripts store
and finally the data store:2.1) Thedeclaration storefolder has no subfolders. It is where your
data asset declarations (YAML files) will reside2.2) Thescripts storefolder is where all your Python & SQL scripts to process data assets will reside.
It should be broken down by subfolderspyfor Python scripts andsqlfor SQL scripts. Please further add
subfoldersdmlandddlinto thesqlscript folder.2.3) Thedata storefolder follows a convention as well,refer to the docson how to structure it.Configure Airtunnel by extending your existingairflow.cfg(as documented here):3.1) Add the configuration section[airtunnel]in which,
you need to add three configuration keys.3.2) adddeclarations_folderwhich takes the absolute path to the folder you set up in 2.13.3) addscripts_folderwhich takes the absolute path to the folder you set up in 2.23.4) adddata_store_folder, which takes the absolute path to the folder you set up in 2.3
for your data storeInstallation requirementsPython >= 3.6,Airflow >=1.10andPandas >= 0.23We assume Airtunnel is implemented best early on in a project, which is why going with a
recent Python and Airflow version makes the most sense. In the future
we might do more tests and include coverage for older Airflow
versions.PySparkis supported from2.3+DocumentationAirtunnel’s documentation ison GitHub pages.
Package: airunner
Stable Diffusion and Kandinsky on your own hardwareNo web server to run, additional requirements to install or technical knowledge required.Just download the compiled packageand start generating AI Art!⭐ FeaturesEasily generate AI art using Stable Diffusion.Easy setup - download and run. No need to install any requirements*Fast! Generate images in approximately 2 seconds using an RTX 2080s, 512x512 dimensions, 20 steps euler_a (approximately 10 seconds for 512x512 20 steps Euler A on 1080gtx). Also runs on CPU†txt2img, img2img, inpaint, outpaint, pix2pix, depth2img, controlnet, txt2vidLayers and drawing toolsImage filtersDark modeInfinite scrolling canvas - use outpainting to create artwork at any size you wish or expand existing images.NSFW filter toggleStandard Stable Diffusion settingsFast load time, responsive interfacePure python - does not rely on a webserverRequirementsCuda capable GPU (2080s or higher recommended)At least 10gb of RAMat least 5.8gb of disc space to install AI RunnerThe core AI Runner  program takes approximately 5.8gb of disc space to install, however the size of each model varies.
Typically models are between 2.5gb to 10gb in size. The more models you download, the more disc space you will need.Using AI RunnerInstructions on how to use AI Runner can be found in the wiki🔧 InstallationDownload the official build on itch.io!This is the compiled version of AI Runner which you can use without installing any additional dependencies.For those interested in installing the development version, there are three options to choose from.See the installation
wiki page for more informationUnit testsUnit tests can be run using the following command:All tests:python -m unittest discover testsIndividual test:python -m unittest tests.test_canvas
Package: air-vapour-pressure-dynamics
Air Vapour Pressure DynamicsRepository with the basic functions related with the temperature, relative humidity, absolute humidity and entalpy of the air.How it work:Create en python environent and install the package using de command:pip install air_vapour_pressure_dynamicsOnce you get installed the package you can import the packahe in the python module by:fromair_vapour_pressure_dynamicsimportvapourpressure,absolutehumidity_kg_air,....orimportair_vapour_pressure_dynamicsSetters:put or remove argument validation::setArgumentCheck(bool)Put or remove Units to results of validation::setApplyUnits(bool)Examples:Basic Example::fromair_vapour_pressure_dynamicsimportabsolutehumidity_kg_airtemp=25.5rh=86.8absolutehumidity_kg_air(temp,rh)17.83208626438017Get units of calculation::fromair_vapour_pressure_dynamicsimportabsolutehumidity_kg_airtemp=25.5rh=86.8ab_hu=absolutehumidity_kg_air(temp,rh)ab_hu.units'g/Kg'Compatibility:NumpySympyBut it is not neccesary to install those packages if you are going to use it only with generic integers or float numbersContent:Functions:vapourpressure(temp)density_air(temp, rh)absolutehumidity_kg_air(temp, rh)absolutehumidity_m3_air(temp, rh)entalpie_kg_air(temp, rh)entalpie_m3_air(temp, rh)moisuredeficit_kg_air(temp, rh)moisuredeficit_m3_air(temp, rh)dew_point_factor(temp, rh)dew_point_temperature(temp, rh)Setters:setApplyUnits(bool)setArgumentCheck(bool)And that it!!