Saravanan666/pypi-org huggingface dataset:
Package: bluetool
### BluetoolA simple Python API for Bluetooth D-Bus calls. Allows easy pairing, connecting and scanning.Also provides a TCP-to-RFCOMM socket bridge for data transfer.#### Dependencies- `python-dbus`- `tcpbridge`The package was tested with **Python 2.7**#### Installation`pip install bluetool`or clone and run `make install`#### Usage- Bluetooth:list: `[{"name": Name, "mac_address": MAC-address}, ... ]`Methods of class Bluetooth:- `start_scanning(timeout)`: `scan` in background- `scan(timeout)`- `get_devices_to_pair()`, returns list- `get_available_devices()`, returns list- `get_paired_devices()`, returns list- `get_connected_devices()`, returns list- `make_discoverable()`, returns bool- `start_pairing(address)`: `pair` in background- `pair(address)`, returns bool- `connect(address)`, returns bool- `disconnect(address)`, returns bool- `trust(address)`, returns bool- `remove(address)`, returns bool- `set_adapter_property(prop, value)`, returns bool- `get_adapter_property(prop)`- `set_device_property(address, prop, value)`, returns bool- `get_device_property(address, prop)`- BluetoothServer:- Step1: Use `run()` to create SPP- Step2: Connect the bluetooth device- Step3: TCPServer is available for connectionUse `shutdown()` to shutdown server.##### Examples- Scanning```pythonfrom bluetool import Bluetoothbluetooth = Bluetooth()bluetooth.scan()devices = bluetooth.get_available_devices()print(devices)```- Using the RFCOMM-TCP Bridge```pythonimport signalfrom bluetool import BluetoothServerdef handler(signum, frame):server.shutdown()tcp_port = 8100server = BluetoothServer(tcp_port)signal.signal(signal.SIGINT, handler)signal.signal(signal.SIGTERM, handler)server.run()```- Using the Bluetooth Agent```pythonimport signalfrom bluetool.agent import Client, AgentSvrclass MyClient(Client):def request_pin_code(self, dev_info):print(dev_info)return raw_input("Input pin code:")def request_passkey(self, dev_info):print(dev_info)return raw_input("Input passkey:")def request_confirmation(self, dev_info, *args):print(dev_info, args)return raw_input("Input 'yes' to accept request:") == "yes"def request_authorization(self, dev_info):print(dev_info)return raw_input("Input 'yes' to accept request:") == "yes"def handler(signum, frame):svr.shutdown()svr = AgentSvr(client_class=MyClient)signal.signal(signal.SIGINT, handler)signal.signal(signal.SIGTERM, handler)svr.run()```### About the projectThis package was written by [Aleksandr Aleksandrov](https://github.com/AD-Aleksandrov) working at [Emlid](https://emlid.com/).The bluetool was originally written for the [Emlid Reach RTK receiver](https://emlid.com/reach/), but we decided to open source it, as there is no easy Python API for BT pairing/connecting. Feel free to add issues and submit pull requests.
Package: bluetooth-adapters
Bluetooth AdaptersTools to enumerate and find Bluetooth AdaptersInstallationInstall this via pip (or your favourite package manager):pip install bluetooth-adaptersContributors ✨Thanks goes to these wonderful people (emoji key):This project follows theall-contributorsspecification. Contributions of any kind welcome!CreditsThis package was created withCookiecutterand thebrowniebroke/cookiecutter-pypackageproject template.
Package: bluetooth-auto-recovery
Bluetooth Auto RecoveryRecover bluetooth adapters that are in an stuck stateCreditsThe code in this repo originates fromhttps://github.com/custom-components/ble_monitor/blob/master/custom_components/ble_monitor/bt_helpers.pyInstallationInstall this via pip (or your favourite package manager):pip install bluetooth-auto-recoveryContributors ✨Thanks goes to these wonderful people (emoji key):This project follows theall-contributorsspecification. Contributions of any kind welcome!CreditsThis package was created withCookiecutterand thebrowniebroke/cookiecutter-pypackageproject template.
Package: bluetooth-data-tools
Bluetooth Data ToolsTools for converting bluetooth data and packetsInstallationInstall this via pip (or your favourite package manager):pip install bluetooth-data-toolsContributors ✨Thanks goes to these wonderful people (emoji key):This project follows theall-contributorsspecification. Contributions of any kind welcome!CreditsThis package was created withCookiecutterand thebrowniebroke/cookiecutter-pypackageproject template.
Package: bluetooth-locker
Bluetooth LockerA simple bluetooth based locker that lock and unlock your linux desktop automatically.How to useYou need to havelibbluetooth-devin your system.# Simple runbluetooth-locker-dxx:xx:xx:xx:xx:xx# Multiple devicesbluetooth-locker-dxx:xx:xx:xx:xx:xx-dxx:xx:xx:xx:xx:aa# Install servicesudobluetooth-locker-dxx:xx:xx:xx:xx:xx--install# Uninstall servicesudobluetooth-locker-dxx:xx:xx:xx:xx:xx--uninstall[Optional] Arduino Bluetooth KeyThough we recommand you to use your phone as the key.Here is a simple arduino bluetooth server implementation.
Package: bluetooth-numbers
bluetooth-numbersPython package with a wide set of numbers related to BluetoothThis project offers a Python package with a wide set of numbers related to Bluetooth, so Python projects can easily use these numbers. The goal of this project is to provide a shared resource so various Python projects that deal with Bluetooth don’t have to replicate this effort by rolling their own database and keeping it updated.The following sources are used:Nordic Semiconductor’sBluetooth Numbers Databasefor Company IDs, Service UUIDs, Characteristic UUIDs and Descriptor UUIDsBluetooth Assigned Numbersfor SDO Service UUIDs and Member Service UUIDsTheIEEE database of OUIsfor prefixes of Bluetooth addressesInstallationYou can install bluetooth-numbers as a package from PyPI with pip:pip install bluetooth-numbersUsageGet the description of a company ID:>>>frombluetooth_numbersimportcompany>>>company[0x0499]'Ruuvi Innovations Ltd.'Get the description of a service UUID:>>>frombluetooth_numbersimportservice>>>fromuuidimportUUID>>>service[0x180F]'Battery Service'>>>service[UUID("6E400001-B5A3-F393-E0A9-E50E24DCCA9E")]'Nordic UART Service'Get the description of a characteristic UUID:>>>frombluetooth_numbersimportcharacteristic>>>fromuuidimportUUID>>>characteristic[0x2A37]'Heart Rate Measurement'>>>characteristic[UUID("6E400002-B5A3-F393-E0A9-E50E24DCCA9E")]'UART RX Characteristic'Get the description of a descriptor UUID:>>>frombluetooth_numbersimportdescriptor>>>descriptor[0x2901]'Characteristic User Descriptor'Get the description of an OUI:>>>frombluetooth_numbersimportoui>>>oui["58:2D:34"]'Qingping Electronics (Suzhou) Co., Ltd'See themodule referencefor complete documentation.LicenseThis project is provided by Koen Vervloesem as open source software with the MIT license. See theLICENSEfile for more information.See also thelicense for the Bluetooth Numbers Databaseused in this package.
Package: bluetooth-sensor-state-data
bluetooth-sensor-state-dataModels for storing and converting Bluetooth Sensor State DataInstallationInstall this via pip (or your favourite package manager):pip install bluetooth-sensor-state-dataContributors ✨Thanks goes to these wonderful people (emoji key):This project follows theall-contributorsspecification. Contributions of any kind welcome!CreditsThis package was created withCookiecutterand thebrowniebroke/cookiecutter-pypackageproject template.
Package: bluetrain
This is a very simple Django CMS application. It allows for the creation of hierarchical pages, adding “focus areas” to the pages along with normal content.
There is also a view for displaying a sitemap (all of the pages tied to home). It relies heavily on terminology from my old web dev days, so it
includes three types of pages:
1. Home page – there should only be one and it should have a slug of ‘home’
2. Normal pages – you get it
3. Constants – these are pages that do not appear in the page hierarchy but can be visited by all,
typically links that appear on all pages, e.g., ‘contact us’INSTALLYou will want to load both files under fixtures via ./manage.py loaddataREQUIRED SETTINGSUSE_CACHE: whether to use Django’s caching or not
DEFAULT_CACHE_TIMEOUT: number of seconds to cache itemsNeither of these settings should be required and I should be providing backup/ defaults for you. Kick me if you are reading this.TEMPLATE TAGSThere’s a single tag in there right now for rendering forms based on the display in default_form.html.
Override this template as needed.TODOMore tests, obviouslyDefault settings
Package: bluewave
BluewaveThis is a Python script to analyze the similarity of two PDFs.UsageTo run this, an example would be:from bluewave.compare_pdfs import compare_pdf_files

filenames = ["file1.pdf", "file2.pdf"]
result = compare_pdf_files(filenames,
                           methods=False,
                           pretty_print=False,
                           verbose=True,
                           regen_cache=True,
                           sidecar_only=False,
                           no_importance=False)To run with AWS connectionfilenames = ["sample_files/sample_file_1.pdf", "sample_files/sample_file_2.pdf"]
aws_config = {
    "profile_name": "default",
    "pdf_bucket": "bluewave2023",
    "cache_bucket": "bluewave2023-cache",
    "pg_username": "postgres",
    "pg_password": "gizmo1228",
    "pg_host": "bluewave.chwv9x0hbowb.us-east-2.rds.amazonaws.com",
    "pg_port": 5432,
    "pg_db": "bluewave",
    "pg_table": "results"
}

result = compare_pdf_files(filenames,
                           methods=False,
                           pretty_print=False,
                           verbose=True,
                           regen_cache=True,
                           sidecar_only=False,
                           no_importance=False,
                           aws_config=aws_config)
Package: bluewhale-canvas-core
Orange Canvas Core is a framework for building graphical user
interfaces for editing workflows. It is a component used to build
the Orange Canvas (http://orange.biolab.si) data-mining application
(for which it was developed in the first place).InstallationOrange Canvas Core is pip installable (https://pip.pypa.io/), simply run:pip install orange-canvas-coreOr use the:pip install ./to install from the sources.DocumentationSome incomplete documentation is available athttps://orange-canvas-core.readthedocs.io
Package: blueye-protocol
blueye.protocolDeprecation noticeBlunux 3.0 introduces a new protocol based onProtobufmessages passed over aZeroMQlayer. Starting with Blunux 3.1 the old TCP/UDP based protocol will no longer be supported/compatible.AboutThis repository contains a python library that defines how to communicate with the underwater drones made byBlueye Robotics.The protocol itself is defined in another repository,ProtocolDefinitions, as is stored as a submodule in this repository. The python code in this repository is (mostly) generated from those definitions.Theblueye.protocolpackage's primary use case is in theblueye.sdk. The SDK implements the necessary "plumbing" to utilize the protocol defined here inblueye.protocol, and will make interacting with the Blueye drones much easier. If you wish to interact with the drones in your own project we recommend using theblueye.sdkpackage, notblueye.protocoldirectly.This package requires Python 3.8 or newer.Installationpipinstallblueye.protocolDevelopmentDependency/Package managementWe use Poetry for dependency/package management, see thePoetry docsfor installation instructions.Code generatorsImportant: This repository includes generated code. If the protocol definitions are changed the generated files need to be updated and committed. The generators are run with:invoke generate-udpinvoke generate-tcpinvoke generate-protoTestsThe tests are located in thetestsfolder, and written using thepytestlibrary.The tests can be run using invoke (to ensure that the protocol files are updated)invoketestor directly using pytest (if you don't want to generate the definitions)pytestsetup.pySince bitbake doesn't have support for pyproject.toml files yet, we need to include asetup.pyfile to specify the dependencies needed. There's an invoke task for
generating the file that can be run withinvokegenerate-setup-pyIf you are running MacOS, you need to install gnu-tarbrewinstallgnu-tarand then run the follwing line before the invoke command:PATH="/opt/homebrew/opt/gnu-tar/libexec/gnubin:$PATH"Be sure to run this script and commit thesetup.pyfile when the dependencies have
changed.
Package: blueye-sdk
blueye.sdkRead Latest Documentation-Browse GitHub Code RepositoryA Python package for remote control of the Blueye underwater drones.About Blueye Underwater DronesBlueye produces and sells three models of underwater drones, the Blueye Pioneer, Blueye Pro, and Blueye X3. The Pioneer and the Pro are drones designed for inspection, while the X3 is extensible with three guest ports that allow attaching for example grippers or sonars.
Visitblueyerobotics.comfor more information about the Blueye products.This SDK and the Blueye dronesA Blueye drone is normally controlled via a mobile device through the Blueye App (iOS/Android).
The mobile device is connected via Wi-Fi to a surface unit, and the drone is connected to the surface unit via a tether cable.This python SDK exposes the functionality of the Blueye app through a Python object. The SDK enables remote control of a Blueye drone as well as reading telemetry data and viewing video streams. It is not meant for executing code on the drone itself.To control the drone you connect your laptop to the surface unit Wi-Fi and run code that interfaces with the through the Python object.Check out theQuick Start Guideto get started with using the SDK.
Package: bluez-dbus-emulator
bluez_dbus_emulatorA simple set of libraries to allow emulating the behavior of a BlueZ
Bluetooth device over DBus.PrerequisitesBefore you begin, ensure you have met the following requirements:dbus_nextInstallationpip3 install bluez_dbus_emulatorUsageFor usage instructions, just follow the examples provided in theexamplesfolder.ContributorsThanks to the following people who have contributed to this project:@Andrey1994LicenseThis project is licensed under the terms of theMIT Licence.
Package: bluezero
A simple Python interface to BlueZ stackName and aimThe aim of this library is to provide an API to access toBluezwithzeroboilerplate code.GoalTo provide a simplified API to people that want to use Bluetooth functionality in their code.
The library will use calls to the BlueZ D-Bus API and use ‘sensible’ defaults to help with that simplification.
It aims to support the ability to create interesting STEM activities without needing to
explain the BlueZ API or write an event loop.In addition to the API, it will contain examples of how to connect to common Bluetooth Smart (BLE) objects
around them (or at least easily accessible to them).
These examples will need to be written without the need to sign (or break) non-disclosure agreements.StatusWhile we want this to be easy to use it does not mean it easy to create.
This library is still in the early stages so things might change and break. Apologies in advance!
We will try to make it as stable as possible. However much of the functionality that is in BlueZ is
still flagged as experimental.
The library assumes you are using a Linux release with BlueZ 5.50. For example Raspberry Pi OS BusterGetting StartedIf you are here for the time, and especially if you are new to Bluetooth Low Energy, then
a tutorial might be a good place to start.
The following tutorial has been created based on the readily available hardware of
a Raspberry Pi and a micro:bit. More details available at:
https://ukbaz.github.io/howto/ubit_workshop.htmlExamplesThere are some other examples in the library if you are feeling adventurousAdapteradapter_example.pyThis will check that it can find the Bluetooth adapter on the computer running the code.
It will print to screen various information and check it is powered before scanning for
nearby devicesGATT Client (Central role)microbit_poll.pyThis example uses the micro:bit API that has been written in bluezero.
You will need a buzzer attached to pin 0 to get play_beep to work.Beaconeddystone_url_beacon.pyA Simple Eddystone URL beacon.
You can be read the URL being broadcast with any Physical Web application on your PhoneScannereddystone_scanner.pyThis example scans for beacons using the common beacon formats of Eddystone URL,
Eddystone UID, AltBeacon and iBeacon.GATT Server (Peripheral role)You will need to have modified the dbus configuration
file to open the permissions for ‘ukBaz.bluezero’. This is covered in the
System Setup section of the documentationcpu_temperature.pyThis example transmits the temperature of the CPU over the single characteristic.
The methodget_cpu_temperature()function creates randomly generated temperature values.
Values are only updated when notification are switched on.ble_uart.pyThis example simulates a basic UART connection over two lines, TXD and RXD.It is based on a proprietary UART service specification by Nordic Semiconductors.
Data sent to and from this service can be viewed using the nRF UART apps from Nordic
Semiconductors for Android and iOS.It uses the Bluezero peripheral file (level 10) so should be easier than the previous CPU
Temperature example that was a level 100.
Package: bluff
bluffBluff is a pythonic poker framework.Currently, bluff covers the following poker variants:Texas Hold'emChinese PokerGetting StartedInstallationUse the package managerpipto install Bluff.pipinstallbluffUsageEvaluating handsimportbluff# Hands can be created by passing Card instances as arguments.hand1=bluff.Hand(bluff.Card("5d"),bluff.Card("4s"),bluff.Card("5s"),bluff.Card("4c"),bluff.Card("5h"),)hand1.name>>>"full_house"Comparing hands valuesimportbluff# Hands can also be created by passing their string representations.hand1=bluff.Hand("5d","4s","5s","4c","5h")# Concatenated strings are also accepted.hand2=bluff.Hand("Jh","Td","Js","5s","8d")hand1.value>hand2.value>>>TrueDrawing a card for a playerimportbluffplayer=bluff.Player(name="Chris Moneymaker",chips=10000)deck=bluff.Deck()card=deck.draw()player.hand.add(card)Evaluating equity with Monte Carlofrombluff.holdemimportequityequity.equity(("QQ","AKo"),times=10000)Evaluating a hand equity against several rangesfrombluff.holdemimportequity# Ranges descriptions.equity.eval_ranges("JTs",("KQs ATo 99","AKs QQ"),times=10000)# Ranges percentages.equity.eval_ranges("JTs",(10,30),times=10000)For more information see thedocumentation.ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.AuthorMatheus Couto-LinkedinLicenseThis project is licensed under theMITLicense.
Package: blume
Better Looking Universal Matplotlib Engine.Blume provides a replacement for the matplotlib table module.Displaying data as tables in matplotlib.It fixes a number of issues with the existing table and has:more reliable code for automatically setting the font size to make
best use of the space available.Padding between text and the cell edges which works better across a
range of text sizes.First row of cell data is now row 0 regardless of whether the table
has a row header.  The row header is row -1.New options to allow cell edge colours to be specified.To use the new table, just importblume.tableand use that to
create your tables instead of thematplotlib.table.table.from blume import table

tab = table(ax, ..)The first parameter to table should be anmatplotlib.axes.If you are using thepyplotinterface, note that callingpyplot.tablewill usematplotlib.table.table.Instead import table from blume and use as follows:from blume.table import table
tab = table(plt.gca(), ...)And lots moreThe general theme is how to create generic tools to explore tables of
data, visualising the data withmatplotlib.Tools that also help with managing open data.For small datasets, there is an evolving example of working with
simple csv files, stored in a git repository.   Seeblume.examples.ocixx.InstallFrom source codeGet the latest code:git clone http://github.com/swfiua/blumeInstal:python setup.py installUsing pip:pip3 install blumeExamplesTheblume/examplesfolder has a number of demonstrations of what can be
done with this table.You can run these with python3:python3 -m blume.example.cprOr you can run a folder full of examples by usingblume.eggshow.RequirementsThe package will only require anappropriateversion of matplotlib.This is to make it easy for anyone who is only here for the table.UniversalThe U inblume.This for now is theblume.cprmodule.TestingRun tests using:pytest tests
Package: blumycelium
BLUMYCELIUM: Async micro-services, 100% in python from BluwrThis tool os provided for free by [bluwr.com](https://bluwr.com). We are building a 100% text based publication platform. A calm space free of any addictive feature.Here are a few things that you can do to support us:Register for early access on [bluwr.com](https://bluwr.com)Buy some awesoms merch on our [store](https://store.bluwr.com)Follow us on social media [instagram](https://www.instagram.com/bluwr_official/), [twitter](https://twitter.com/bluwr_official), [linkedin](https://www.linkedin.com/company/bluwr)Machine Elf <- Mycelium -> Machine ElfPLEASE NOTE: This documentation is a work in progressBLUMYCELIUM is our tool for arm’s-length microservices management and orchestration. It allows for the splitting of a monolithic application into several small parts that run asynchronously in the same environment and can be tested separately. BLUMYCELIUM was developed to be easy to learn and does not require more than python knowledge to achieve results that would normally be implemented using more complex DevOps orchestration tools mediated through REST APIs. To achieve this, Blumycellium relies heavily on python introspection capabilities to follow the flow of variable updates and transparently derives execution and orchestration graphs. By allowing services to be separate programs BLUMYCELIUM applications can also bypass the python GIL. BLUMYCELIUM also remembers the source code of all tasks as well as tracebacks for all exceptions for easy debugging. BLUMYCELIUM is implemented using the flexible multimodal ArangoDB database for storing what we call the: Mycelium. The repository of everything needed for variable execution graphs, source codes, orchestrations and failure reporting.BLUMYCELIUM allows you to write complex microservice orchestration all in python. You can divide a complex application into many smaller parts that can be tested independtly and ran asynchronously. These smaller parts are agents calledMachine Elvesand theMyceliumis the database they use to communicate.Readthedocs documentationWe provide a full documentation [here](https://blumycelium.readthedocs.io/en/latest/index.html) (work in progress).FeedbackIf you have any suggestions about features or feedback about the documentation please open github issues.