Saravanan666/pypi-org huggingface dataset:
Package: pyGATB
MacOSXLinuxAbout pyGATBpyGATB is a Python3 wrapper for theGATB-Core
library.The current release of pyGATB gives access to the following GATB-Core
components:Bank: the class that enables to load Fasta and Fastaq filesSequence: the class that holds a sequence (ID, letters, quality)Graph: the class that holds the De Bruijn graphNode: the class that makes graph’s nodesUsing that API you can start prototyping algorithms:read a sequence file (Bank): FastA, FastQ (plain text or gzipped)or read a set of files (still using the same Bank!)convert that Bank to a De Bruijn graph (Graph)navigate through the Graph (Node)all of that directly using the Python Programming Language.DocumentationJump to the wikito review how
to install, use and make pyGATB Python3 compliant codes.LicensepyGATB and GATB-Core are free softwares; you can redistribute it and/or
modify it under theAffero GPL v3
license.
Package: pygate-grpc
Pygate gRPC clientBackgroundA Python interface toTextile'sPowergateFilecoinAPI. See the projectwebsitefor more details.InstallYou can get started usingpygate_grpcby installing it through the PyPi repository.pip install pygate_grpcUsageThe main component of the package is thePowerGateClientclass.Here is a basic usage example of the pygate_grpc:frompygate_grpc.clientimportPowerGateClientclient=PowerGateClient("127.0.0.1:5002",is_secure=False)build_info=client.build_info()Simple as that!Note: this examples assumes you have a Powergate server running with an API available at127.0.0.1:5002. See Textile's PowergateLocalnet. Theis_secure=Falseflag indicates that SSL is not enabled on this server.Examples of more elaborated usage can be found in theexamplesfolder.ContributingPlease read contributionguidelinesbefore starting development.To setup your development environment make sure you have the following software:GitPythonpippipenv( or runpip install pipenv)Clone the repositorygit clone https://github.com/pygate/pygate-gRPC.gitInstall dependenciesThe runtime and development dependencies can be installed in a new virtual environment automatically by running the following command in the project root directory:pipenv install --devNOTE: The--devflag can be ommited if you only need runtime dependenciesUsing the virtual environmentTo run any command through pipenv's virtual environment you can spawn a new virtual environment shell by running:pipenv shellCode StyleThis project usesblackcode formatter for consistency. Since the are not any precommit hooks defined in the repository yet please format your code before opening a pull request.Automatic formatting can be performed by running:pipenv run formatRunning the testsCurrently the test suite is very minimal. Full Testing is in the project's roadmap but it will be developed only if the timeframe of the Hackathon allows to do so.Integration TestsIntegration tests spin up a localnet using the official script from powergate repository and the test cases are run using that network. By implication, to run the test make sure you have the following dependencies installed:docker-composedockergitTo run the integration tests run:pipenv run integration-testVersioningWe useSemVerfor versioning. For the versions available, see thetags on this repository.To automatically bump the version of the package run:bump2version major|minor|patch setup.pyFinally, to push the new version to git and trigger a new release action it is necessary to add the--tagsflag at the time of pushing. i.e.:git push origin main --tagsLicenseMIT © Antreas Pogiatzis, Wang Ge, Peter Van Garderen, Aaron Sutula
Package: pygates
PyGatesPyGates is a library for using the logic gates as a conditions on Python.InstallationPyGates can be installed using:pipinstallpygatesOr if you have multiple versions of Python and pip on your machine, try:pip3installpygatesAlternatively, you can pull the library directly from GitHub:gitclonehttps://github.com/Baticaly/PyGatescdPyGates
pythonsetup.pyinstallUsageYou can just basicaly use the gates as a condition like:PyGates.Gates.AND('input1', 'input2')Or just for calling the functions easily you can create a basic definition for library:import pygates
lg = pygates.GatesAnd you can easily call it by using:lg.AND('input1', 'input2')GatesGateFunctionANDPyGates.Gates.AND( 'A' , 'B' )NANDPyGates.Gates.NAND( 'A' , 'B' )ORPyGates.Gates.OR( 'A' , 'B' )NORPyGates.Gates.NOR( 'A' , 'B' )XORPyGates.Gates.XOR( 'A' , 'B' )XNORPyGates.Gates.XNOR( 'A' , 'B' )LicenseMIT LicenseCopyright (c) 2020 Batuhan ErgünPermission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Package: pygate-webapp
pygate-webappA Filecoin Flask template application for Python developers using Textile.io'sPowergateand thePygate gRPCclient.InstallationClone files and cd to directory:git clone https://github.com/pygate/pygate-webapp && cd pygate-webappSet up virtualenv:virtualenv venvActivate virtualenv:source venv/bin/activateInstall requirements:pip install -r requirements.txtCreate the application database:python create_db.pypygate-webapp is built using thePython Flaskframework. To start the built-in development server:python run.pyGo tolocalhost:5000in your browser to use the app.This is a development release of the pygate-webapp. It is designed to work with a DockerizedLocalnet Powergate. It assumed this is running at the127.0.0.1:5002address. You can change the POWERGATE_ADDRESS in theconfig.pyfile.FeaturesUpload a file or multiple files from your local machine to the Filecoin network.Download them from Filecoin back to your local machine.Check Wallet balances.Change Filecoin Filesystem (FFS) configuration settings and push them to files in storage.Review logs of your activities in the Pygate webapp.
Package: pygating
PyGatingPyGating is a small but simple python library that enables you to quickly introduce a/b testing, control code flow, and introduce control switches to your codebase that can be controlled via both code and json-based configs.PyGating supports entity-based checks, allowing you to define in the gating configuration exactly the properties, functions, and/or keys the gate will check based on a entity you will pass in at check time.Check out the respositoryherefor more information and documentationFeaturesExtensible Framework: Create custom gates by extending base gate classes.Entity-based gates: Define gate configurations based on entity properties/functions to make gates dynamicConsistant Hashing: Entity-based gate checks will pass/fail consistently based on property hashingJSON Configuration: Supports gate configuration defined in json so that you can pull gates configs from databasesPredefined Gates: IncludesDateGate,PercentageGate,RandomGate,InclusionGate, and more.Custom Gate Configurations: Combine gates to create complex gating logic.Quick Usage ExampleThis example will only permit 10% of entities/code invocations to continue.We can use either a RandomGate for pure 10% random chance or a PercentageGate for a consistant result based on the passed entityInitialize Pygating Library and importsfrompygatingimportPyGatingfrompygating.gating_configurationsimportGatingConfigurationAllfrompygating.gatesimportPercentageGatePyGating.init()# only needs to be done once in the applicationDefine a gate config (code or json):Code-based configgate_config=GatingConfigurationAll(fail_closed=True,#if an exception is thrown, the gate check returns Falsegates=[PercentageGate(percentage=10,allow=True,entity_property="id")# 10% of entities passed into the gate check will pass based on their id field])orJson-based configgate_config={"type":"GatingConfigurationAll","fail_closed":true,"gates":[{"type":"PercentageGate","percentage":10.0,"allow":true,"entity_property":"id"}]}Use gate in your code:classEntity:def__init__(self,id:str):self.id=idexample_entity=Entity(id="dfa2oi1nrffvnoivwe")ifPyGating.check_gating(gate_config,entity=entity):print("Gate passed!")# Will pass for 10% of entity ids, and will be consistent for the same idselse:print("Gate Failed")Installationpipinstallpygating
Package: pyGATs
pyGATsThis library is in development process. API is not stabilized yet. It will
be completely changed soon.This is python3 library which combines power of pyautogui, opencv, tesseract,
markdown and other staff to automate end-to-end and exploratory testing.This library might be used to automate testing process with Xvbf and docker.pyGATs depends on pyautogui, pytesseract, opencv and others. Please see section
dependencies in pyproject.toml file.How to testpython3 -m pytestLinterpylint $(git ls-files '*.py')Build documentationcd docs
make html
Package: pygatttool
PyGatttoolA wrapper aroundgatttoolandpexpect, intended to be used as a simple BLE development tool for interacting with peripheral devices.RequirementsA workinggatttoolinstall.If installing from the repo you needpexpect(pip install pexpect).Installationpip install pygatttoolUsageThe following code (frompolarpy) starts the raw PPG stream on a Polar OH1. The address and attribute handles for your particular device can be found usinggatttoolor another BLE tool such as nRF Connect.from pygatttool import PyGatttool

OH1_ADDR = "XX:XX:XX:XX:XX:XX"
OH1_CONTROL_ATTRIBUTE_HANDLE = 0xXX
OH1_DATA_ATTRIBUTE_HANDLE = 0xXX

if '__main__' == __name__:
    ble = PyGatttool(address=OH1_ADDR)

    ble.connect()
    ble.mtu(232)
    ble.char_write_req(handle=OH1_CONTROL_ATTRIBUTE_HANDLE + 1, value=0x200)
    ble.char_write_req(handle=OH1_DATA_ATTRIBUTE_HANDLE + 1, value=0x100)
    ble.char_write_cmd(handle=OH1_CONTROL_ATTRIBUTE_HANDLE, b'\x02\x01\x00\x01\x82\x00\x01\x01\x16\x00')

    while True:
        print(ble.wait_for_notification(handle=OH1_DATA_ATTRIBUTE_HANDLE))the output will look something like this:01 00 b2 92 28 f4 52 82 07 00 ce ff 03 71 54 05 f3 60 05 a8 f2 ff 30 00 04 c6 54 05 07 60 05 8a f2 ff 3a ff 03 8c 54 05 88 5f 05 65 f2 ff 97 ff 03 e4 54 05 04 5f 05 41 f2 ff 17 ff 03 d6 54 05 70 5e 05 18 f2 ff a7 ff 03 6d 54 05 4f 5e 05 4b f2 ff 78 ff 03 8b 54 05 5b 5e 05 0b f2 ff 3f 00 04 48 54 05 a0 5e 05 08 f2 ff 18 00 04 f3 54 05 ca 5e 05 13 f2 ff 93 ff 03 84 54 05 67 5f 05 08 f2 ff 26 00 04 66 55 05 f1 5e 05 34 f2 ff e0 ff 03 be 55 05 81 5f 05 0b f2 ff dc ff 03 b2 55 05 c1 5f 05 0b f2 ff 75 00 04 b5 56 05 2b 60 05 2c f2 ff a8 ff 03 a5 56 05 6b 60 05 d6 f1 ff 89 00 04 57 57 05 88 60 05 3a f2 ff d9 00 04 55 57 05 33 61 05 3b f2 ff 45 01 04 7f 57 05 a0 61 05 38 f2 ff 
01 00 b2 72 30 f4 52 82 07 00 4e 01 04 a0 58 05 f2 60 05 49 f1 ff a2 01 04 a6 58 05 28 62 05 3e f2 ff 5f 02 04 41 59 05 9a 62 05 37 f2 ff 16 02 04 1a 5a 05 34 63 05 4e f2 ff 43 02 04 1d 5a 05 1e 63 05 47 f2 ff 05 03 04 ea 5a 05 ba 63 05 3f f2 ff 18 03 04 aa 5a 05 93 64 05 4a f2 ff a7 03 04 b1 5b 05 82 64 05 e6 f1 ff 6f 03 04 ff 5b 05 47 65 05 0d f2 ff e3 03 04 3c 5c 05 47 65 05 51 f2 ff 7b 04 04 db 5c 05 d7 65 05 8d f2 ff 98 04 04 d6 5c 05 3a 66 05 45 f2 ff 38 05 04 d3 5d 05 b3 66 05 5b f2 ff 72 05 04 7d 5d 05 ea 66 05 9d f2 ff b4 05 04 b2 5e 05 3d 67 05 4c f2 ff 8f 05 04 4b 5e 05 57 67 05 61 f2 ff 3c 06 04 ca 5e 05 66 67 05 2d f2 ff fe 05 04 2e 5f 05 93 67 05 16 f2 ff 

...IssuesWhile readily available,gatttoolis long deprecated.It is somewhat unfortunate thatgatttooldoes not appear report a version number. Thepexpectcode is looking for specific response strings, so if those strings change even slightly between versions it will break PyGatttool. That being said, it has been tested on several versions of Ubuntu 20+ without any issues, and given the deprecation it is probably unlikely that it will change.
Package: pygaul
OverviewEasy access to administrative boundary defined by FAO GAUL 2015 from Python scripts.This lib provides access to FAO GAUL 2015 datasets from a Python script. it is the best boundary dataset available for GEE at this point. We provide access to The current version (2015) administrative areas till level 2.install it using eitherpiporconda:pip install pygauland then request area of interest from their name or GADM Id:importpygaulgdf=pygaul.Items(name="Singapore",content_level=1)Notethe dataset was generated in 2015 by the Food and Alimentation Organization (FAO). It has not been updated on Google Earthengine since then. Use with caution on disputed territories.CreditsThis package was created withCookiecutterand the12rambau/pypackageproject template.
Package: pygauth
PygAuthA Python helper library for Google AuthenticationInstallationInstall from pypi!https://pypi.org/project/pygauth/UsageGet Service Account Credentialsget_sa_creds(sa_file: Union[str, Path], scopes: List[str] = None)

sa_file: file to read SA creds from
scopes: list of scopes to auth withExamples:pygauth.get_sa_creds("creds.json")# get sa creds with no scopespygauth.get_sa_creds("creds.json",scopes=["drive"])# get sa creds using shorthand scopepygauth.get_sa_creds("creds.json",scopes=["https://www.googleapis.com/auth/drive"])# get sa creds using longhand scopeGet User Account CredentialsFrom File:get_user_creds_file(creds_file: Union[str, Path], scopes: List[str] = None, create_cache: bool = True, refresh_cache: bool = False, remote: bool = False)

creds_file: file to read oauth portal credentials from
scopes: list of scopes to auth with
create_cache: whether to use the .pygauth cache file
refresh_cache: overwrites whatever is cached with a new value automatically
remote: whether to use remote auth or local auth (use when on a headless server)From Dict:get_user_creds_dict(creds_dict: Dict[str, str], scopes: List[str] = None, create_cache: bool = True, refresh_cache: bool = False, remote: bool = False)

creds_dict: dictionary of oauth portal credentials
scopes: list of scopes to auth with
create_cache: whether to use the .pygauth cache file
refresh_cache: overwrites whatever is cached with a new value automatically
remote: whether to use remote auth or local auth (use when on a headless server)Examples:>>>creds_dict=json.load(open("credentials.json"))>>>creds=pygauth.get_user_creds_file("credentials.json",scopes=["drive"])# authenticate using filePleasevisitthisURLtoauthorizethisapplication:https://accounts.google.com/o/oauth2/auth...>>>creds=pygauth.get_user_creds_dict(creds_dict,scopes=["iam"])# authenticate using dictPleasevisitthisURLtoauthorizethisapplication:https://accounts.google.com/o/oauth2/auth...>>>creds=pygauth.get_user_creds_file("credentials.json",scopes=["drive"])# authenticate using file# doesn't ask for another login since this scope has already been authenticated
Package: pygaze
PyGazePyGaze is a wrapper for the outstanding work ofpytorch_mpiigaze_demoandeth-xgazeto provide a simple api to estimate the gaze of humans, either on images or in realtime.Installationpip install pygazeAPIFirst create an instance ofPyGaze.Callpredicton the instance to get a list of faces in the image and a gaze vector.To render information extracted from an image, instanciatePyGazeRendererand callrender()according to the examples.Example usagefrompygazeimportPyGaze,PyGazeRendererimportcv2image=cv2.imread("jonas.jpg")pg=PyGaze()pgren=PyGazeRenderer()gaze_result=pg.predict(image)forfaceingaze_result:print(f"Face bounding box:{face.bbox}")pitch,yaw,roll=face.get_head_angles()g_pitch,g_yaw=face.get_gaze_angles()print(f"Face angles: pitch={pitch}, yaw={yaw}, roll={roll}.")print(f"Distance to camera:{face.distance}")print(f"Gaze angles: pitch={g_pitch}, yaw={g_yaw}")print(f"Gaze vector:{face.gaze_vector}")print(f"Looking at camera:{pg.look_at_camera(face)}")img=pgren.render(image,face,draw_face_bbox=True,draw_face_landmarks=False,draw_3dface_model=False,draw_head_pose=False,draw_gaze_vector=True)cv2.imshow("Face",img)cv2.waitKey(0)cv2.destroyAllWindows()TodoAdd a flag topredict()to pass already detected faces in an image.
Package: pygazebo
pygazebo provides python bindings for the Gazebo
(http://gazebosim.org) multi-robot simulator.GitHub:https://github.com/jpieper/pygazeboFree software: Apache 2.0 LicenseDocumentation:http://pygazebo.rtfd.org.FeaturesSupports publishing and subscribing to any Gazebo topics using a
straightforward python API.Python versions of all defined Gazebo protobuf messages are
included.Based on asyncio/trollius for flexible concurrency support.Simple UsageThe following example shows how easy it is to publish a message
repeatedly to control a single joint in a Gazebo model running on the
local machine on the default port.importtrolliusfromtrolliusimportFromimportpygazeboimportpygazebo.msg.joint_cmd_pb2@trollius.coroutinedefpublish_loop():manager=yieldFrom(pygazebo.connect())publisher=yieldFrom(manager.advertise('/gazebo/default/model/joint_cmd','gazebo.msgs.JointCmd'))message=pygazebo.msg.joint_cmd_pb2.JointCmd()message.axis=0message.force=1.0whileTrue:yieldFrom(publisher.publish(message))yieldFrom(trollius.sleep(1.0))loop=trollius.get_event_loop()loop.run_until_complete(publish_loop())History3.0.0-2014.1 (2014-07-04)Switch from eventlet to trollius/asyncio, for better compatibility
with other event loops and future python versions.Update to gazebo 3.0.02.2.1-2014.2 (2014-06-04)Properly support sending and receiving large messages.2.2.1-2014.1 (2014-02-11)First release on PyPI.
Package: pygba
PyGBAA Python wrapper around the Game Boy Advance emulator mGBA with built-in support for gymnasium environments.UsagePyGBA is designed to be used by bots/AI agents. It provides an easy-to-use interface to interact with the emulator as well as agymnasiumenvironment for reinforcement learning.While any GBA ROM can be run out-of-the box, if you want to do reward-based reinforcement learning, you might want to use a game-specific wrapper that provides a reward function. Currently, only a wrapper forPokemon Emeraldis provided, but more will be added in the future.A gym environment can be created as follows:frompygbaimportPyGBA,PyGBAEnv,PokemonEmeraldrom_path="path/to/pokemon_emerald.gba"gba=PyGBA.load(rom_path,autoload_save=True)# if autoload_save is True, a save file will be loaded if one exists next to the ROMgame_wrapper=PokemonEmerald()# optionally customize the reward function by passing additional argumentsenv=PyGBAEnv(gba,game_wrapper)InstallationInstall PyGBA with pip using:pipinstallpygbaYou'll also need to installmGBAwith Python bindings. By default, mGBA is installed without Python bindings, so until the situation is improved, you'll need to build mGBA from source.Installing mGBAMGBA PACKAGE IS CURRENTLY BROKEN (help wanted)For Python >= 3.10 on Linux and macOS, you can use the pre-built wheels from here:pipinstallmgbaFor Windows and older Python versions, you'll need to build mGBA from source. See the the next section for instructions.Building mGBA from sourceOfficial installation instructions can be foundhere, but here's a quick summary.
The important detail is that Python bindings have to be enabled by passing-DBUILD_PYTHON=ONto CMake.First, clone the mGBA repository:gitclonehttps://github.com/mgba-emu/mgba.gitcdmgbaUnix:
On Unix-based systems, run the following commands:mkdirbuildcdbuild
cmake-DCMAKE_INSTALL_PREFIX:PATH=/usr-DBUILD_PYTHON=ON..
make
sudomakeinstallmacOS:
On macOS, additional dependencies are required:brewinstallcmakeffmpeglibzipqt5sdl2libeditluapkg-config
mkdirbuildcdbuild
cmake-DCMAKE_PREFIX_PATH=`brew--prefixqt5`-DBUILD_PYTHON=ON..
make
sudomakeinstallNote: If bothqtandqt5are installed you might run into issues. If that's the case, try uninstallingqt.Windows:
Please follow the official instructionshere.After compiling mGBA, the Python bindings should be built atbuild/python/lib.{platform}-{architecture}-cpython-{version}/mgba.
To use it in your Python code, you'll need to add it to yourPYTHONPATHenvironment variable.You can check if the bindings were built and installed correctly by runningpython -c "import mgba"(should output nothing).
Package: pyg-base
pyg-basepip install fromhttps://pypi.org/project/pyg-base/base contains a range of various utilities that help quick research.date functions: dt, drange, calendarextending the Dict: ulist, Dict, named_dict, treedictablevarious decorators: try_none, loop(list), timer, etc.zipper: a safer version of zippandas utilities: df_reindex, df_sync, df_fillna, nona, df_slice, add_, sub_, mul_, div_, pow_async waiter to allow awaiting dicts and lists of awaitables more easily
Package: py-GBdistribution
py-GBdestribution is a Python package that calculates the Gaussian and Binomial distributions of input data.Quick StartFirst, install the library:$ pip install py-GBdistributionExample>>> from py_GBdistribution import Gaussian, Binomial
>>> g = Gaussian(3, 4)
>>> g.mean
3
>>> g.stdev
4
>>> b = Binomial(0.4, 20)
>>> b.mean
8.0
>>> b.stdev
2.1908902300206643UpdatesMore updates will be made soon
Package: pygbm
pygbmExperimental Gradient Boosting Machines in Python.The goal of this project is to evaluate whether it's possible to implement a
pure Python yet efficient version histogram-binning of Gradient Boosting
Trees (possibly with all the LightGBM optimizations) while staying in pure
Python 3.6+ using thenumbajit compiler.pygbm provides a set of scikit-learn compatible estimator classes that
should play well with the scikit-learnPipelineand model selection tools
(grid search and randomized hyperparameter search).Longer term plans include integration with dask and dask-ml for
out-of-core and distributed fitting on a cluster.InstallationThe project is available on PyPI and can be installed withpip:pip install pygbmYou'll need Python 3.6 at least.DocumentationThe API documentation is available at:https://pygbm.readthedocs.io/You might also want to have a look at theexamples/folder of this repo.StatusThe project is experimental. The API is subject to change without deprecation notice. Use at your own risk.We welcome any feedback in the github issue tracker:https://github.com/ogrisel/pygbm/issuesRunning the development versionUse pip to install in "editable" mode:git clone https://github.com/ogrisel/pygbm.git
cd pygbm
pip install -r requirements.txt
pip install --editable .Run the tests with pytest:pip install -r requirements.txt
pytestBenchmarkingThebenchmarksfolder contains some scripts to evaluate the computation
performance of various parts of pygbm. Keep in mind that numba's JIT
compilationtakes
time!ProfilingTo profile the benchmarks, you can usesnakevizto get an interactive
HTML report:pip install snakeviz
python -m cProfile -o bench_higgs_boson.prof benchmarks/bench_higgs_boson.py
snakeviz bench_higgs_boson.profDebugging numba type inferenceTo introspect the results of type inference steps in the numba sections
called by a given benchmarking script:numba --annotate-html bench_higgs_boson.html benchmarks/bench_higgs_boson.pyIn particular it is interesting to check that the numerical variables in
the hot loops highlighted by the snakeviz profiling report have the
expected precision level (e.g.float32for loss computation,uint8for binned feature values, ...).Impact of thread-based parallelismSome benchmarks can call numba functions that leverage the built-in
thread-based parallelism with@njit(parallel=True)andprangeloops.
On a multicore machine you can evaluate how the thread-based parallelism
scales by explicitly setting theNUMBA_NUM_THREADenvironment
variable. For instance try:NUMBA_NUM_THREADS=1 python benchmarks/bench_binning.pyvs:NUMBA_NUM_THREADS=4 python benchmarks/bench_binning.pyAcknowledgementsThe work from Nicolas Hug is supported by the National Science Foundation
under Grant No. 1740305 and by DARPA under Grant No. DARPA-BAA-16-51