Saravanan666/pypi-org huggingface dataset:
Package: bluebelt
BluebeltTools for HR AnalyticsCopyright (C) 2020 Arvid HahnéThis program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.You should have received a copy of the GNU General Public License
along with this program.  If not, seehttps://www.gnu.org/licenses/.What is Bluebelt?Bluebelt is a collection of python tools that can be used in HR analytics projects. The package is far from complete but it is in active development.How does it work?The package is highly dependent on Pandas. There a two ways to use the functions available.... to be continued ...
Package: blueberrywsn
blueberrywsnblueberrywsn is an application developed during an undergraduate
project for the Distributed Systems course of the Federal
Technological University of Paraná. It can be used to create a server
and clients to establish a Bluetooth network that monitors the light
sensors of each client.ImplementationThe implementation of the server and client of blueberrywsn is based
on the RFCOMMexamplesof the Bluetooth Python extension modulePyBluez, which is also a dependency of this application.InstallationFirst, make sure to installPyBluez’sdependencies:sudo apt-get install python-dev libbluetooth-devFinally, blueberrywsn can be installed withpip:sudo pip install blueberrywsnUsageStart the device as a server with:blueberrywsn serverStart the device as a client with:blueberrywsn clientPressenterorctrl + cto stop.AuthorsThe authors who worked on the project are:Felipe DauFelipe S. RuffoGabriel RubinoGustavo D. de OliveiraJosé A. P. ContóLuis R. G. MargaridoRayara dos Santos FragosoRenata C. SoaresTamires Priscila da CostaVitor G. TakahashiDevelopersThe authors who developed this application are:felipedauferuffogabrielrubinobrGuDiasOliveira
Package: bluebild
Bluebild PackageThe Bluebild algorithm offers a more robust, efficient way to calculate the sky intensity distribution. Bluebild is a flexible spherical imager for interferometric applications. It uses principle component analysis to calculate the sky intensity matrix in a series of energy levels. This provides astronomers with images of the sky decomposed into different energy levels, allowing for easy denoising through filtering low energy levels and recombination of the eigen-images in statistically optimal ways. With low computational complexity and affinity for parallel execution, Bluebild is an excellent candidate for next-generation radio-astronomy imaging. With additional optimization and parallelization, it may even achieve real-time imaging in the field.
Package: bluebild-tools
bluebild-toolsTools around bluebild@EPFLInstallation$ pip install bluebild-tools --upgradeUsageCheck whether CuPy can be usedfrom bluebild_tools import cupy as bbt_cupy
use_cupy = bbt_cupy.is_cupy_usable()You can set theMUST_CUPYenvironment variable to influence the behavior of the function:WithMUST_CUPYunset or set to 0, theuse_cupyboolean variable will be set toFalseif CuPy can't be used and set toTrueif CuPy can be used.WithMUST_CUPYset to 1, the process will be killed if CuPy is not usable.WithMUST_CUPYset to 0, no attempt will be made to use CuPy (i.e.use_cupywill be set toFalse, always).NoteIf CuPy is found unusable, the following environment variables are automatically set to 0:CUPY_PYFFSCUPY_PYLOPSThat way, the pyFFS (https://github.com/imagingofthings/pyFFS) and PyLops (https://github.com/PyLops/pylops) packages can be imported with CuPy support disabled.
Package: bluebird-stoick01
BlueBirdSimple deep learning library.UsageInstall:pip install bluebird-stoick01Here is a simple implemetation of a model in bluebird.from bluebird.nn import NeuralNet
from bluebird.activations import Relu, Softmax
from bluebird.layers import Input, Dense
from bluebird.loss import CategoricalCrossEntropy
from bluebird.optimizers import SGD

# create the neural net
net = NeuralNet([
    Input(200), # input layer
    Dense(100, activation=Relu()),  # hidden layers with relu activation
    Dense(50, activation=Relu()),
    Dense(10, activation=Softmax()) # last hiddent layer with softmax activation
])

# define optimizer and loss function
net.build(optimizer=SGD(lr=0.003), loss=CategoricalCrossEntropy())

# train your model
net.fit(X_train, y_train, num_epochs=20)For more info checkout thedocsRoadmapThere are a lot of updates planed, you will find comments throughout the library that define what features I'm planing to add in the future.ContributionFeel free to help, I know that there are many things that need to be optimized and implemented in the future, any help is welcome.
Package: bluecat-libraries
Modules for working with products from BlueCat Networks.The Python clients in this package provide access to the following BlueCat HTTP APIs:Address Manager RESTful v2 API (9.5)Address Manager Legacy REST v1 API (9.3, 9.4, 9.5)Address Manager Failover APIDNS Edge APINoteBlueCat strongly recommends using the RESTful v2 API instead of the Legacy v1 API.
The RESTful v2 API strictly adheres to HTTP 1.1 constraints as detailed in RFC 2616,
and allows for cleaner, more understandable code.The examples below illustrate how to use the Address Manager RESTful v2 API and Legacy v1
API to fetch BlueCat Address Manager (BAM) configurations.Examples using Address Manager RESTful v2 APIfrombluecat_libraries.address_manager.apiv2importClient,MediaTypeimportcsv# Retrieve the configurations. Request the data as per BAM's default content type.withClient(<bam_url>)asclient:client.login(<username>,<password>)response=client.http_get("/configurations")configurations=response["data"]forconfigurationinconfigurations:print(f'{configuration["id"]}:{configuration["name"]}')client.logout()# Retrieve the configurations. Request that the response is in 'JSON' format.# The result should contain only fields 'id' and 'name'.withClient(<bam_url>)asclient:client.login(<username>,<password>)response=client.http_get("/configurations",params={"fields":"id,name"},headers={"Accept":MediaType.JSON},)configurations=response["data"]forconfigurationinconfigurations:print(f'{configuration["id"]}:{configuration["name"]}')client.logout()# Retrieve configurations. Request that the response is in 'CSV' format.# The result should contain only the first 10, ordered alphabetically by name.withClient(<bam_url>)asclient:client.login(<username>,<password>)configurations_csv=client.http_get("/configurations",params={"orderBy":"asc(name)","limit":"10"},headers={"Accept":MediaType.CSV},)configurations=list(csv.reader(configurations_csv.splitlines()))forconfigurationinconfigurations:# NOTE: The 'id' is the first value in a row, the 'name' is the third one.print(f"{configuration[0]}:{configuration[2]}")client.logout()Example using Address Manager Legacy REST v1 API# Fetch all configurations from a BlueCat Address Manager server.frombluecat_libraries.address_manager.apiimportClientfrombluecat_libraries.address_manager.constantsimportObjectTypewithClient(<bam_url>)asclient:client.login(<username>,<password>)configs=client.get_entities(0,ObjectType.CONFIGURATION)client.logout()forconfiginconfigs:print(config)NoteSubpackagebluecat_libraries.address_manager.api.rest.provisionalis a deprecated dependency of
BlueCat Gateway, and currently exists while we are still in the pre-deprecation-removal grace
period. It will be removed in the next release of BlueCat Libraries.
Package: bluecatnovamonitor
version number: 0.0.1
author: Brian ShorlandOverviewBlueCat Nova MonitorInstallation / UsageTo install use pip:$ pip install bluecatnovamonitorOr clone the repo:$ git clonehttps://github.com/bshorland/bluecatnovamonitor.git$ python setup.py installContributingTBDExampleTBD
Package: bluecellulab
BlueCelluLabLatest ReleaseDocumentationLicenseBuild StatusCoverageGitterCitationThe Blue Brain Cellular Laboratory is designed for simulations and experiments on individual cells or groups of cells.
Suitable use cases for BlueCelluLab include:Scripting and statistical analysis for single cells or cell pairs.Lightweight, detailed reporting on specific state variables after simulation.Developing synaptic plasticity rules.Validating dynamics of synaptic properties.Automating in-silico whole-cell patching experiments.Debugging, both scientifically and computationally.CitationWhen you use this BlueCelluLab software for your research, we ask you to cite the following reference(this includes poster presentations):@software{bluecellulab_zenodo,
  author       = {Van Geit, Werner and Tuncel, Anil and Gevaert, Mike and Torben-Nielsen, Benjamin and Muller, Eilif},
  title        = {BlueCelluLab},
  month        = jul,
  year         = 2023,
  publisher    = {Zenodo},
  doi          = {10.5281/zenodo.8113483},
  url          = {https://doi.org/10.5281/zenodo.8113483}
}SupportWe are providing support onGitter. We suggest you create tickets on theGithub issue trackerin case you encounter problems while using the software or if you have some suggestions.Main dependenciesPython 3.8+Neuron 8.0.2+InstallationBlueCelluLab can be pip installed with the following command:pipinstallbluecellulabQuick StartThe following example shows how to create a cell, add a stimulus and run a simulation:frombluecellulab.cellimportcreate_ball_stickfrombluecellulabimportSimulationcell=create_ball_stick()sim=Simulation()sim.add_cell(cell)stimulus=cell.add_step(start_time=5.0,stop_time=20.0,level=0.5)sim.run(25,cvode=False)time,voltage=cell.get_time(),cell.get_soma_voltage()# plotting time and voltage ...TutorialA more detailed explanation on how to use BlueCelluLab, as well as other examples can be found on theexamples page.API DocumentationThe API documentation can be found onReadTheDocs.Running the testsTesting is set up usingtox:pipinstalltoxtox-epy3# runs the teststox-elint# runs the format checksFunding & AcknowledgementsThe development and maintenance of this code is supported by funding to the Blue Brain Project, a research center of the École polytechnique fédérale de Lausanne (EPFL), from the Swiss government’s ETH Board of the Swiss Federal Institutes of Technology.CopyrightCopyright (c) 2023 Blue Brain Project/EPFLThis work is licensed underApache 2.0For MOD files for which the original source is available on ModelDB, any specific licenses on mentioned on ModelDB, or the generic License of ModelDB apply.The licenses of the morphology files used in this repository are available on:https://zenodo.org/record/5909613
Package: bluechi
BlueChi Python bindingsThe BlueChi Python bindings provides a Python module to interact with the D-Bus API of BlueChi. It consists of the
following subpackages:api: auto-generated code based the BlueChi D-BUS API descriptionext: custom written code to simplify common tasksInstallationUsingpip3:# from PyPipip3installbluechi# or from cloned git repopip3install--forcedist/bluechi-<version>-py3-none-any.whlExamplesListing all connected nodes and their current state:frombluechi.apiimportControllerfornodeinController().list_nodes():# node[name, obj_path, status]print(f"Node:{node[0]}, State:{node[3]}")Starting and stopping of a systemd unit on a specific node using theUnitclass from theextsubpackage to
implicitly wait for the job to finish:frombluechi.extimportUnithu=Unit("my-node-name")result=hu.start_unit("chronyd.service")print(result)result=hu.stop_unit("chronyd.service")print(result)
Package: blue-chip
blue-chipOne click Python code quality packageblue-chipusesblack,isort,invokeandprospectorconfigured to work well together out of the box.InstallThe recommended installation method when installing globally is to usepipxpipx install blue-chipOtherwise (for best results) usepipto install directly into your project's virtual environment.pip install blue-chipUsingpoetry.poetry add --dev blue-chipUsingpipenvyou need to pin the version.pipenv install --dev blue-chip==0.0.8Command-line useList the possibleblue-chipcommands withbc --list$bc --list

Subcommands:

  fmt    Format python source code.
  lint   Run static analysis on python source code.
  sort   Sort module imports.Enterprise useEnterprise teams may find it useful to fork and redistribute this package with their own custom defined standards.In many cases this is a simple as changing the package name and values inblue_chip/constants.py.For fine grain control of the static analysis tools, edit theprospectorprofiles inblue_chip/config.
Package: blue-combine
BLUE methodA description of the BLUE method as implemented in this package can be found inL. Lyons, D. Gibaut and P. Clifford,
"How to Combine Correlated Estimates of a Single Physical Quantity",
Nucl. Instrum. Meth. A 270 (1988) 110,
doi:10.1016/0168-9002(88)90018-6.A. Valassi,
"Combining correlated measurements of several different physical quantities",
Nucl. Instrum. Meth. A 500 (2003) 391,
doi:10.1016/S0168-9002(03)00329-2.Usagethe examples directory contains different usage possibilitiesbasic_blue.py: basic usage of the BLUE class (example in Nucl. Instrum. Meth. A 270 (1988) 110)from_correlation_matrix.py: use uncertainties and correlation matrix as inputuncertainty_sources.py: specify different uncertainty sources with individual correlationsreduced_correlations.py: use the "reduced correlations" option
(reduce a 100% correlation to rho = sigma_X/sigma_Y, assuming sigma_X <= sigma_Y)
Package: bluecon
BlueConLibrary for connecting to Fermax Blue supported doorbells.Tested Devices:Fermax Veo XS WiFi (9449)InstallationpipinstallblueconAcknowledgementsI'd like to thank all contributors ofpush_receiverand its many forks for provinding a library that can receive push notifications from Firebase. This is the essencial part of how Fermax Blue works in terms of receiving the doorbell rings and without it this project would be close to pointless. This library is included with some minor changes in this repo.
Package: bluecurrent-api
Blue Current ApiPython wrapper for the blue current apiThe library is an asyncio-driven library that interfaces with the Websocket API provided by Blue Current. This was made for the Blue Current Home Assistant integration.UsageRequirementsPython 3.11 or newerwebsocketspytzInstallationpipinstallbluecurrent-apiApi tokenUsing this library requires a Blue Current api token. You can generate one in the Blue Current driver portal.Examplefrombluecurrent_apiimportClientimportasyncioasyncdefmain():api_token='VDLAU17BLVKNNK6X2MBUD007MWNHN9R2'client=Client()# data receiverasyncdefon_data(data):print('received: ',data)# validate and set token.awaitclient.validate_api_token(api_token)# example requestsasyncdefrequests():awaitclient.get_charge_points()awaitasyncio.sleep(10)awaitclient.disconnect()# connect and send requestsawaitasyncio.gather(client.connect(on_data),requests())asyncio.run(main())Implemented methodsThe methods validate_token and get_email are stand-alone and are to be used before connecting to the websocket with connect().await validate_token(api_token) -> strValidates the given token.await get_email() -> strReturns the account's email.await connect(receiver)Connects to the websocket.Calls get_charge_points and get_charge_cards when connection is established.is_connected() -> boolReturns if the client is connectedawait wait_for_charge_points()Waits until chargepoints are received.get_next_reset_delta() -> TimeDeltaReturns the timedelta to the next request limit reset (00:00 Europe/Amsterdam).await disconnect()Stops the connection.Dataawait get_charge_points()Gets the chargepointsawait get_charge_cards()Returns the users charge cards.await get_status(evse_id)Gets the status from a chargepoint.await get_settings(evse_id)Gets the setting states from a chargepoint.await get_grid_status(evse_id)Gets the grid status from a chargepoint.Settingsawait set_linked_charge_cards_only(evse_id, value)Sets set_linked_charge_cards_only.await set_plug_and_charge(evse_id, value)Sets set_plug_and_charge.await block(evse_id, value)Blocks or unblocks a charge point.Actionsawait reset(evse_id)Resets the chargepoint.await reboot(evse_id)Reboots the chargepoint.await start_session(evse_id card_uid)Starts a charge session.await stop_session(evse_id)Stops a charge session.
Package: bluedart
Python BlueDart SOAP API Module===============================:Author: Vatsal Shah:Maintainer: Vatsal Shah:License: BSD:Status: StableWhat is it?-----------A light wrapper around Bluedart's Webservice Soap API. I don't do much of anyvalidation, but I'll help you sort through the pile of SOAP objects BlueDartuses.Installation------------The easiest way is via pip or easy_install::pip install bluedartQuick Start------------ Clone this repository.- Edit the `example_profile.py` file in See `examples/ <examples/>`_ with your bluedart credentialsand run any of the provided examples.Support-------Issues & Questions: https://github.com/hornedbull/bluedart/issuesMost problems are going to require investigation or a submittedpull request.To contribute a new feature or service, feel free to create a pull request.We are always looking for new contributors to help maintain the project.Todos------ Increase service specific request validation- Remove deprecated services (package movement service)Legal-----Copyright (C) 2008-2016 Vatsal ShahThis software is licensed under the MIT License.
Package: bluedb
use my database, is good!>>> from BlueDB import Blue
>>> database = Blue('database')
>>> database['key'] = {'nested key': 'nested value'}
>>> print(database['key']['nested key'])
nested value
>>> database['key']['nested key'] = 'new value'
>>> print(database)
{'key': {'nested key': 'new value'}}py-mpip install BlueDBto install it then importBlueclass and you’re good to go!Blue2Blue2 ~ A BlueDB subsetBlue2 uses JSON to make it faster and more human readable. Blue2 also sticks with the same framework and design as the original BlueDB.>>> from BlueDB.blue2 import Blue
>>> database = Blue('database')
>>> database['key'] = {'nested key': 'nested value'}
#same functions and features as BlueDB...but more JSON!!!
>>> print(database['key']['nested key'])
nested value
#WOW very JSON!!!
>>> database['key']['nested key'] = 'new value'
>>> print(database)
{'key': {'nested key': 'new value'}}Blue2 can use Builtin JSON, UltraJSON or RapidJSONBlue3Blue3 ~ A BlueDB superset>>> from BlueDB.blue3 import Blue
>>> database = Blue('database')
>>> database['key'] = {'nested key': 'nested value'}
>>> database2 = Blue('database')
>>> print(database); print(database2)
{'key': {'nested key': 'nested value'}} #database
{'key': {'nested key': 'nested value'}} #database2
>>> database['key']['nested key'] = 'new value'
>>> print(database); print(database2)
{'key': {'nested key': 'new value'}} #database
{'key': {'nested key': 'new value'}} #database2Blue3 can also use Builtin JSON, UltraJSON or RapidJSONHow is it different?What makes Blue3 different from both the original BlueDB and Blue2 is Blue3 has a special feature which lets you open and run multiple versions of the same database and have fluent consistent data flow across all of them. Meaning when you edit data in one version of the database it will automatically update that information into every other version.How is it faster?Blue3 uses JSON, in-memory caches and memory monitoring to incrementally dump data from in-memory to disk, making key setting and getting faster and more efficient. The same principal is used in the library [Chest](ttps://github.com/mrocklin/chest) from which I got the idea to spill to disk.Is this the best version of BlueDB?Currently yes. Will it be the best overall? no, BlueDB will have better and faster versions in the future. All of my any or up and coming work can be seen in [Indev](BlueDB/indev)
Package: bluedo
OverviewBlueDo - Bluetooth proximity automationLock your desktop, mute music or run any other command when leaving your PC. There are dozens of apps like this. This one just aims to make it beautiful, modern and easy.Not all bluetooth devices works for this. Some devices randomizes the bluetooth address as a privacy feature, some disconnects to save power. If you have trouble using your phone, try a headset, watch, etc.Only Bluetooth is supported, not Bluetooth Low-Energy (BLE).Maturity2 is in beta1 is deprecatedInstallationFrom pipsudo apt install python3-pip gir1.2-appindicator3-0.1
pip3 install --upgrade bluedoOptional apt packagesplayerctl(pause music),amixer(for mute/unmute).From debFetch deb file from https://github.com/ways/BlueDo/releasesFrom sourcesudo apt install python3-dev libbluetooth-dev playerctl libgirepository1.0-dev libcairo2-dev gir1.2-appindicator3-0.1Then install requirements:pip install -r requirements.txtRequirementsUse these system commands:bluetoothctlhcitoolloginctlgsettingsamixer (mute)playerctl (pause music)Version > 2.0 is only tested on Ubuntu 22.04 with GNOME.Version < 2.0 is only tested on Ubuntu 20.04-21.04 with GNOME.Command line options-e / --enable to start service on app start.-m / --minimize to start minimizedConfigurationThere are lots more options in the config file. Feel free to tune.ScreenshotsSystem changesNote that this app will make these changes to your power management:Enable screen lock:org.gnome.desktop.screensaver lock-enabled trueSet delay from screen blacking to locking to zero:org.gnome.desktop.screensaver lock-delay 0Set screen saver timeout to 10 seconds when device is away, 5 minutes when device is present:org.gnome.desktop.session idle-delay 600TODOCheck for dependencies on startupDefault lock / unlock ON.Keep two instances from running at the same time.Minimize to tray, instead of having both minimize and minimize to tray.Stop device scanning when minimizedChange to dynamic widget layout instead of fixed.Change preferences button to proper burger menu.Move media files to some other dir?Unit testsWhen on xfce:for bluetooth settings, open blueman-managerto lock/unlock change xscreensaver timeout, to match functionality from gnomeDevelopment docsscan for devices: bluetoothctl devicesrssi for device: hcitool rssi ff:ff:ff:ff:ff:ff (unstable?)Version below .56 needs Python < 3.9, bluetoothctl ~5.50 or newer.hard locking: lock when no signalsoft locking: set screensaver timeout to 10 seconds when no signalInspirationhttps://github.com/LukeSkywalker92/btproxipybt_rssi.py is from this project and is MIT licensed.https://discourse.gnome.org/t/useful-documentation-for-gtk/29Black/white icons in app fromhttps://material.io
Package: bluedot
Blue DotBlue Dotallows you to control your Raspberry Pi projects wirelessly - it's a Bluetooth remote and zero boiler plate (super simple to use :) Python library.Getting startedInstallsudo pip3 install bluedotGet theAndroid Blue Dot appor use thePython Blue Dot appPair your Raspberry PiWrite some codefrombluedotimportBlueDotbd=BlueDot()bd.wait_for_press()print("You pressed the blue dot!")Press the Blue DotSee thegetting started guideto 'get started'!MoreBlue Dot is more than just one button. You can create as many buttons as you want and change their appearance to create your own controller.Every button is also a joystick. You can tell if a button was pressed in the middle, on the top, bottom, left or right. You can easily create a BlueDot controlled Robot.Why be restricted by such vague positions like top and bottom though: you can get the exact (x, y) position or even the angle and distance from centre where the button was pressed.Its not all about when the button was pressed either - pressed, released or moved they all work.A button can be any colour, square, given give or hidden!You can press it, slide it, swipe it, rotate it - one blue circle can do a lot!Even moreTheonline documentationdescribes how to use Blue Dot and the Python library including recipes and ideas.