Saravanan666/pypi-org huggingface dataset:
Package: blueetl
BlueETLMultiple simulations analysis tool.IntroductionBlueETLis a package that can help analyse multiple simulations in a Simulation Campaign.It automatically usesBlue Brain SNAPorBluePyto open simulations, circuits, and reports.Contribution GuidelinesSeeCONTRIBUTING.rst.CitationWhen you use this software, we kindly ask you to cite the following DOI:AcknowledgmentThe development of this software was 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.For license and authors, seeLICENSE.txtandAUTHORS.txtrespectively.Copyright © 2023 Blue Brain Project/EPFL
Package: blueetl-core
blueetl-coreCore transformations for BlueETL.IntroductionBlueETL-coreautomatically registers Pandas accessors using the.etlnamespace, that can be useful to simplify some recurring operations on Pandas DataFrames, Series, and Indexes.It provides the core transformations used byBlueETL, a package that can help analyse multiple simulations in a Simulation Campaign.InstallationBlueETL-corecan be installed independently fromBlueETLwith:pip install -U blueetl-coreExamplesTo use the Core Transformations provided by the.etlaccessor with any Pandas DataFrame or Series, it’s enough to import BlueETL or BlueETL-core, and call the desired methods.For example:importblueetl_coreimportpandasaspddf=pd.DataFrame({"a":[0,1,2],"b":[3,4,5]})df=df.etl.q(a=1)Seethis Jupyter notebookfor more information and examples.Contribution GuidelinesSeeCONTRIBUTING.rst.CitationWhen you use this software, we kindly ask you to cite the following DOI:AcknowledgmentThe development of this software was 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.For license and authors, seeLICENSE.txtandAUTHORS.txtrespectively.Copyright © 2023 Blue Brain Project/EPFL
Package: bluefin
python-bluefin is a Python API client for theBluefinPayment System API.
The only thing this client module does is serialize and pass the data on to
the Bluefin API gateway, it performs little to no validation. Values are passed
into an API function in dict form, and responses come back in a similar
dict format.Notepython-bluefin is not at all endorsed by Bluefin Payment Systems in
any way. We have published this API module with the hope that it will be
useful to someone else.Statuspython-bluefin has been in use in production for about a year with a high
transaction volume. The directmode client in particular has seen lots of use.That said, we only use a little sliver of what Bluefin supports (one-off
credit card charges, namely). Given that python-bluefin is a very light
wrapper, other usage cases should still work just fine, even if we (the
maintainers) haven’t used them yet.InstallingTo install:pip install --upgrade bluefinA quick exampleHere’s a very bare-bones example of how to use the Direct Mode V3Client. We
pass in the required key/values via a Python dict, and get a dict result. All
of these values are documented in the Bluefin API documentation, so look there
for help on just what is being passed in and coming back.>>> from bluefin.directmode.clients import V3Client
>>> api = V3Client()
>>> result = api.send_request({
    'pay_type': 'C',
    'tran_type': 'A',
    'account_id': 123456789012,
    'amount': 1.0,
    'card_number': 4444333322221111,
    'card_expire': '1212',
    'dynip_sec_code': 'SECURITY_CODE_HERE',
})
>>> print result
{
    'avs_code': 'X', 'auth_msg': 'TEST APPROVED',
    'status_code': 'T', 'ticket_code': 'XXXXXXXXXXXXXXX',
    'auth_date': '2011-06-22 19:04:30', 'settle_currency': 'USD',
    'auth_code': '999999', 'settle_amount': '1', 'cvv2_code': 'M',
    'processor': 'TEST', 'trans_id': '123456789012'
}Running Unit TestsInstall nose.Copytests/api_details.blank.pytotests/api_details.pyEdittest/api_details.pyto reflect your account number and security code.From within thepython-bluefindir, runnosetestsLicensepython-bluefin is licensed under theBSD License.
Package: blueflask
Blue Flask==========Flask boilerplate to create projects with the idea of pluggable blueprints.Installation------------.. code-block::pip install blueflaskUsage-----The following command allows you to create a new app:.. code-block:: pythonblueflask newapp <APP_NAME> <OPTIONAL_DEST_DIRECTORY>Tutorial--------Creating A New App~~~~~~~~~~~~~~~~~~Let's assume that we are going to start a project called **bluedemo**. Executeon your terminal:.. code-block::blueflask newapp bluedemoThis will create a directory with the name of the project and define a basicstructure for your project layout.Running The APP~~~~~~~~~~~~~~~Next, go inside the directory of your project and install the dependencies.If you are using *virtualenv* then, create and/or activate your environmentbefore executing the following command bellow install your dependencies... code-block::pip install -r requirements.txtNow your project is ready to run. Execute the following command to startthe server:.. code-block::python run.pyOr you can execute one of the Flask standard ways to run the application:.. code-block::export FLASK_APP=run.pyflask runOr:.. code-block::python -m flask runEither one will start the application running on port 5000. Now you can go toyour browser and enter:+ `http://localhost:5000/<http://localhost:5000/>`_+ `http://localhost:5000/demo/<http://localhost:5000/demo/>`_You can play with some URLs like: `http://localhost:5000/demo/about/?value=some_random_value<http://localhost:5000/demo/about/?value=some_random_value>`_As you can see, the last two URLs have a */demo* prefix. This is defined in the *blueprints/demo/config.py* file by the *url_prefix* under the *BLUEPRINT_INIT* dictionary. You can change the value of this for whatever you want or set it to *None* if you don't want any prefix.Understanding Your Application~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~Now that you have your application running, have a look to the basic architecture defined by BlueFlask. Look inside the *app/blueprints*directory. As you can see, there is a *main* and a *demo* directory. These directories are consider *pluggable-blueprint*, according to the BlueFlask idea. The structure of this directory is pretty simple:+ *__init__.py:* Makes the current directory a Python package.+ *config.py:* Blueprint specific settings and definitions.+ *urls.py:* Routes for that blueprint.+ *views.py* Functions or classes in charge of handing requests.Feel free to define more modules as you need them. I.e: *models.py*,*service.py*, *utils.py*, etc.Creating A New Blueprint.~~~~~~~~~~~~~~~~~~~~~~~~~To create a new blueprint, you just have to create a new directory insidethe *blueprints* directory.
Package: bluegalaxyenergy
Blue Galaxy EnergyHologram: Shut up! You do not know the power of the Blue Galaxy Energy! Also known as the "B.G.E"Mr. Whereabout: The Loss, Part III, Volume IBlueGalaxyEnergy is a tool to perform the so-called BGE attack described inCryptanalysis of a White Box AES Implementation, Olivier Billet, Henri Gilbert, Charaf Ech-Chatbiwith the optimizations proposed in:Improved cryptanalysis of an AES implementation, Ludo TolhuizenRevisiting the BGE Attack on a White-Box AES Implementation, Yoni De Mulder, Peter Roelse, Bart PreneelCompileTo compile and install the project, install gmp and ntl libraries and development headers (available in your OS package manager), e.g.$sudoaptinstalllibgmp-devlibntl-devor$sudopacman-Sgmpntlthen compile and install the package locally:$pipinstallbluegalaxyenergyTest$python3-mbluegalaxyenergy--selftestRun the attackfrombluegalaxyenergyimportWhiteBoxedAES,BGEclassMyWhiteBoxedAES(WhiteBoxedAES):def__init__(self,...):# TODOdefgetRoundNumber(self):# return the number of rounds of the whitebox (10 for AES128,#   12 for AES192 and 14 for AES256)return10defapplyRound(self,data,roundN):# Apply a round of the whitebox on a buffer# [param] data    a buffer of 16 bytes (type bytes)# [param] roundN  the round number to apply (int in the range [0, self.getRoundNumber()) )# return  16 bytes of the encrypted data by the roundreturn...# TODOmywb=MyWhiteBoxedAES(...)# run the attackbge=BGE(mywb)bge.run()# extract the key from the available roundKeykey=bge.computeKey()ifkeyisnotNone:print("key:",key.hex())By default, the methodrun()will extract all the rounds (except the last one who
doesn't have a mixColumns). You can limit which round to use for the attack
with the optionroundList:bge.run(roundList = [4,5,6,7,8]). However, the
attack needs three consecutive rounds in order to extract one round key.
For AES128, a minimum of three consecutive rounds is needed to extract the key.
For AES192 and AES256, the minimum is four consecutive rounds.LimitationsThe implementation can be used on AES-whiteboxes which encrypt, not on those
which decrypt.The implementation does not cover the randomization in the order of the bytes
of the intermediate results in AES, mentioned in De Mulder paper.AboutAuthors and ContributorsInitial Authors and Contributors:Laurent GrémyNicolas SurbayrolePhilippe TeuwenFor next contributions, see the git projet history.CopyrightQuarkslabLicenseBlueGalaxyEnergy is provided under theApache 2.0 license.
Package: blue-heron
blue-heronpython package for interacting with AutoDesk Eagle filesthis is a pre-release version and the api is subject to change.installationdevelopmentinstallationto install for development:git clone ${REPO_URL} ${PATH_TO_ROOT}
pip install -e ${PATH_TO_ROOT}teststox is reccomendedtoxinstall toxpip install toxrun tox from the root directorytoxpytest (not reccomended)make sure pytest is installedrun pytest from the root directorypytestpackagingmake sure the PyPA's build package is installedpython3 -m pip install --upgrade buildrun build from the root dirpython3 -m build
Package: blue-interface
blue_interface[API Reference] [Examples]Blue Interface is a platform-agnostic Python API for controlling Blue robotic
arms. It usesrosbridgeto
communicate with Blue's ROS-based control system over a network connection.Features:No dependency on ROS (or any particular version of Ubuntu)Easy connection to multiple robotsSupport for both Python 2 and 3Support for Mac, Windows, and LinuxSupport for Jupyter NotebooksIt's designed to be lightweight and easy-to-use! Sending a Blue "right" arm to
its zero position, for example, is as simple as:fromblue_interfaceimportBlueInterfaceblue=BlueInterface(side="right",ip="127.0.0.1")blue.set_joint_positions([0]*7)InstallationFrom PyPi:pipinstallblue_interfaceFrom source:gitclonehttps://github.com/berkeleyopenarms/blue_interface.gitcdblue_interface
pipinstall-e.Examplesgripper_controller.py- An example of opening and closing Blue's gripper.inverse_kinematics.py- An example of sending Blue an end effector pose
command.print_status.py- An example of reading state and printing values from Blue.zero_position.py- An example of sending Blue a command in joint space.
Package: bluelink
🚙 BlueLinkUnofficial Python API wrapper for Hyundai'sBluelink®. Allows you to remotely control your Hyundai car via Python.Installingpip install bluelinkDocumentationDocumentation can be found below. See code for more details.UsingYou can use this module either through the built-in CLI, or directly through Python.lock,unlock,start,stop,find, andodometerare supported.CLINote that every individual command will sign-in in to BlueLink. If you plan on chaining commands, you should use the Python API.$exportBLUELINK_EMAIL=<email>
$exportBLUELINK_PASSWORD=<password>
$exportBLUELINK_PIN=<pin>

$bluelinkcars
Elantra-<vin>
SantaFe-<vin>

$bluelink<vin>lock
Locking...

$bluelink<vin>unlock
Unlocking...# 'dsh' stands for 'driver seat heat'# 'psh' stands for 'passenger seat heat'$bluelink<vin>start--duration=10--temp="LO"--defrost--dsh=4--psh=4Starting...

$bluelink<vin>stop
Stopping...

$bluelink<vin>find
Latitude:<latitude>
Longitude:<longitude>

$bluelink<vin>odometer7,643PythonThe Python wrapper comes with two classes:BlueLinkandCar. The former is the main class that allows logging into the service, and the latter is a wrapper for specific cars linked to the account.frombluelinkimportBlueLink# Logins to BlueLink. You may also choose to set the username, password,# and pin via environment variables (same convention as the CLI) and# leave the arguments blank.bl=BlueLink(email='<email>',password='<password>',pin='<pin>')bl.login()# Prints the BlueLink object.print(bl)# BlueLink(email=<email>, is_logged=True)# Print all of the cars in the account. 'cars' is a standard dictionary.forvin,carinbl.cars.items():print(vin,car)# <vin> Car(nickname=<nickname>, bluelink=<has_bluelink>)# Gets the first car.elantra=bl.cars['<vin>']elantra.lock()# Returns True if successful.elantra.unlock()# Returns True if successful.elantra.start(duration=10,temp="LO",defrost=True,driver_seat_heat=4,passenger_seat_heat=4,)# Returns True if successful.elantra.stop()# Returns True if successful.elantra.find()# Returns a tuple of (latitude, longitude).elantra.odometer# Returns an integer. Note this is a property, and not a method.
Package: bluemaestro-ble
bluemaestro-blebluemaestro BLE devicesInstallationInstall this via pip (or your favourite package manager):pip install bluemaestro-bleContributors ✨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: bluemax
bluemaxbluemax is a python rpc server using websockets.The concept is that you can write python functions and
expose them in the__all__property of the module.The complexity comes when you want to do more than
this. And that is what I am working on. The most
important pattern to me is being able to insert, update
and delete in the database and be able to broadcast
the changes to all users after the actor gets their
response. I call it broadcast_on_success.actor   crud    broadcast
      |       |         |
      |------>|         |
      |       |         |
      |<------|         |
      |       |-------->|
      |       |         |
      |<------|---------|
      |       |         |The errors from crud are local to the actor. The actor
will receive identity on success and then like every
other user hear about crud via broadcast.Using annotations allows clients to
infer function. See the sample.add function.For deployment of multiple servers see:http://www.tornadoweb.org/en/stable/guide/running.html#running-behind-a-load-balancerTo use:pip install bluemaxTo install:python3.7 -m venv venv
. venv/bin/activate
pip install -e git+https://bitbucket.org/blueshed/bluemax.git#egg=bluemaxTo run you can choose either with workers using redis or standalone.To run standalone:bluemax run.server -m bluemax.tests.fooTo run with redis:pip install bluemax[redis]
docker run -p 6379:6379 -d redis:2.8Then create a conf.yml file containing:---
procedures: tests.foo
services: tests.foo.services
REDIS_URL: redis://localhostThen run a worker in one terminal
and a server in the another.bluemax run.worker -c conf.ymlandbluemax run.services -c conf.ymlandbluemax run.server -c conf.ymlNow go tohttp://localhost:8080and add some numbers.To build your own project try:bluemax sidney oliveYou can use any name for your module. It will create extension points for logs,
settings, urls and a base procedures modules. bluemax will look for your
procedures.allin the module you pass in.
Package: blue-media
What is it?A wrapper of the api logic used to interact with blue_media.Why is it needed?I just wanted to do it, no why.How to use it?Installing the librarypip install blue_mediaImporting the libraryfrom blue_media import BlueClassInitialize the Config Classconfig = Config(**kwargs)Initialize the BlueMedia Classblue = BlueMedia(config)Call the GET and POST methodsblue.async_get(**kwargs)
blue.async_post(**kwargs)By: "_"
Package: bluemix-service-discovery
# Overview[![Build Status](https://travis-ci.org/IBM-Bluemix/service-discovery-client-python.svg?branch=master)](https://travis-ci.org/IBM-Bluemix/service-discovery-client-python)This is the source code for bluemix-service-discovery, a pip package that serves as a client to Python apps attempting to interact with the Bluemix Service Discovery service.## How To Use1. Open a terminal and run```bashpip install bluemix-service-discovery```2. Import the package wherever you want to register your service or lookup a service in the registry.```pythonfrom bluemix_service_discovery.service_publisher import ServicePublisherpublisher = ServicePublisher('test-service', 300, 'UP','https://test-service.mybluemix.net', 'http',tags=['test'])``````pythonimport jsonfrom bluemix_service_discovery.service_locator import ServiceLocatorservices = json.loads(locator.get_services()).get('instances')```## Example appTo see how to use this client in your app please check out the [Logistics Wizard](https://github.com/IBM-Bluemix/logistics-wizard) demo. You will want to pay attention to [server/web/\_\_init\_\_.py](https://github.com/IBM-Bluemix/logistics-wizard/blob/master/server/web/__init__.py) for a service registration and [server/utils.py](https://github.com/IBM-Bluemix/logistics-wizard/blob/master/server/utils.py) for a service lookup example.## More Info[Service Discovery](https://console.ng.bluemix.net/catalog/services/service-discovery/)[Documentation](https://console.ng.bluemix.net/docs/services/ServiceDiscovery/index.html)## LicenseSee [License.txt](License.txt) for license information.
Package: blueonion
easy to use as most of the data returned are pandas DataFrame objectscan be easily saved as csv, excel or json filescan be inserted into MySQL or MongodbTarget Usersfinancial market analyst of Worldlearners of financial data analysis with pandas/NumPypeople who are interested in financial dataInstallationpip install blueonionUpgradepip install blueonion –upgradeQuick Startimport blueonion as ts

pro = ts.pro_api('dfcf7cda6b195dc2966a4baeab0fcaea4b809edb6c10e70a')
pro.query('esgData', isin='AEA006101017', pageSize=2, pageNo=2)
pro.query('fundData', isin='AEA006101017')
pro.query('equityData', isin='AEA006101017')return:open    high   close     low     volume    p_change  ma5
date
2012-01-11   6.880   7.380   7.060   6.880   14129.96     2.62   7.060
2012-01-12   7.050   7.100   6.980   6.900    7895.19    -1.13   7.020
2012-01-13   6.950   7.000   6.700   6.690    6611.87    -4.01   6.913
2012-01-16   6.680   6.750   6.510   6.480    2941.63    -2.84   6.813
2012-01-17   6.660   6.880   6.860   6.460    8642.57     5.38   6.822
2012-01-18   7.000   7.300   6.890   6.880   13075.40     0.44   6.788
2012-01-19   6.690   6.950   6.890   6.680    6117.32     0.00   6.770
2012-01-20   6.870   7.080   7.010   6.870    6813.09     1.74   6.832
Package: blueox
BlueOx - A python application logging frameworkBlueOx is a python based logging and data collection framework. The problem it
attempts to solve is one where you have multiple python processes across
multiple hosts processing some sort of requests. You generally want to collect:Performance data (counters, timers, etc)User activityErrors (and debugging data)Use BlueOx to record that data, aggregate it to a central logging server where
it can be written to disk.In addition, it’s often useful to be able to plug reporting scripts into the
logging server so as to generate live stats and reports or do ad hoc analysis.BlueOx’s collection functionality is fairly advanced allowing heirarchies of
collectors and queuing in the event of failure. For example, it’s recommend to
run an instance ofoxdon each host, and then configure each of those
collectors to forward log events to a central collector on a dedicated log
machine.See README.md for full details
Package: bluepie
Irnas Bluepie SoftwareThis repository contains often used BLE wrappers aroundbleak.Installation and updatingUse the package managerpipto install BluePie like below.
Rerun this command to check for and install  updates.pipinstallbluepieDevelopingFor development and testing the use ofvirtualenvis suggested.Installvirtualenv:pipinstallvirtualenvCreate and activatevirtualenv, run this from project root:virtualenvvenv
./venv/bin/activateTo make development of the python package more smooth you can run below command from the project root directory.
Changes that you make in the source code will be automatically available instead of runningpip install .all time.pipinstall--editable.Creating a PyPi packageImportant: bump version insetup.pyfile.Twine package is needed:pipinstalltwineCreate a wheel:python3setup.pysdistbdist_wheelCheck if everything is ok:twinecheckdist/*Upload to Test PyPi:twineupload--repository-urlhttps://test.pypi.org/legacy/dist/*After you made sure that everything is ok you can upload to PyPi:twineuploaddist/*LicenseFirmware and software originating from this repository is licensed under theGNU General Public License v2.0.Open-source licensing means the hardware, firmware, software and documentation may be used without paying a royalty, and knowing one will be able to use their version forever. One is also free to make changes, but if one shares these changes, they have to do so under the same conditions they are using themselves. The name IRNAS is a mark of IRNAS LTD. This name and term may only be used to attribute the appropriate entity as required by the Open Licence referred to above. The names and marks may not be used in any other way, and in particular may not be used to imply endorsement or authorization of any hardware one is designing, making or selling.
Package: blueprint-client
Please :star: this repo if you find it usefulBlueprint ClientBlueprint sample client library.Installationpython3-mpipinstall-Ublueprint_clientUsage examplefromblueprint_client.clientimportClientusername="user"password="pass"client=Client(username,password)data=client.get_data()client.change_something(True)Contributions are welcome!This is an active open-source project. We are always open to people who want to
use the code or contribute to it.We have set up a separate document containing ourcontribution guidelines.Thank you for being involved! :heart_eyes:Authors & contributorsThe original setup of this library is byAndrey "Limych" Khrolenok.For a full list of all authors and contributors, checkthe contributor's page.LicenseMIT LicenseSee separatelicense filefor full text.
Package: blueprint-decr
A tiny python lib for decorating all view functions of a flask
blueprint.installpip install blueprint-decrusage# api_blueprint is a blueprint object

import functools
def dummy_decr(func):
    @functools.wraps(func)
    def wrapper(*sub, **kw):
        print(func.__name__)
        return func(*sub, **kw)
    return wrapper


import blueprint_decr

new_api_blueprint = blueprint_decr.attach(api_blueprint, dummy_decr)

# now, you may register new_api_blueprint with flask app object.
# app.register_blueprint(new_api_blueprint, url_prefix='/api')
Package: blueprinter
BlueprinterGenerates easy-to-use blueprints for your end users.Example UsageTo see an example of how to use Blueprinter, run the following in a python script:from blueprinter.templates import inline
inline()CapabilitiesCurrently, Blueprinter provides 'inline' snippets.When called, your example code or template will replace the contents of the calling file.Future additions to this library will allow entire folders to be written to the calling file's directory of choice.<style>
    h1{font-family: 'Cabin Sketch', cursive; font-size: 4rem;color:#0072dc}
</style>
Package: blueprintpy
OverviewGeneric package configuration CLI generatorDescriptionblueprintpyis a generic utility that provides package configuration CLI likenpm initorswift init.By default it contains generic pypi-compliant Python package and CMake-compliant C++ configuration, but you can customize it.Furthermore, each configuration is managed as template usingJinja2, so you can create your own template.Installationblueprintpy can be installed from PyPI. The CLI toolblueprintwill also be installed.pip install blueprintpyDocumentsDocuments and API references are publised atGitHub Pages.LicenseThis repository is published underMIT License.