Saravanan666/pypi-org huggingface dataset:
Package: bice
BICEA numerical path continuation software for algebraic equations, ODEs, and PDEs.Implements methods for the parameter continuation (arclength method) in the solution space of
a user-defined equation and provides a toolbox for the stability and bifurcation analysis.In addition, interfaces to various solvers and time-stepping methods are provided.InstallationTo install the latest published version from PyPI simply execute:pip3installbiceAlternatively,bicecan be installed locally using the source code from ourgit repository.RequirementsThe software depends on Python 3 and the following third-party packages:numpy,scipy,matplotlib,findiff, andnumdifftools.
All will be installed automatically when installingbice.TutorialsWe have first tutorials!Heat equation tutorial: a simple tutorial on how to use bice to implement a first partial differential equation and perform a time simulation of it.Swift-Hohenberg equation tutorial: a simple tutorial on how to use bice's path continuation capabilities.Predator-prey model tutorial: an introduction into the continuation of periodic orbits.More will follow soon.Meanwhile you can check out the less documenteddemos.DocumentationClick here for theonline version of the documentation.
Package: biceps
BICePs - Bayesian Inference of Conformational PopulationsThe BICePs algorithm (Bayesian Inference of Conformational Populations)
is a statistically rigorous Bayesian inference method to reconcile
theoretical predictions of conformational state populations with sparse
and/or noisy experimental measurements and objectively compare different
models. Supported experimental observables include:NMR nuclear Overhauser effect(NOE).NMR chemical shifts(HA,NH,CAandN).J couplings(both small molecules and amino acids) (J).Hydrogen--deuterium exchange(HDX).CitationCheck ourBICePs websitefor more details!Please check out thetheory ofBICePsto learn more.Installation (in progress)BICePs supports Python 2.7 (seetag v1.0) or Python 3.4+ (v2.0 or greater) on Mac, Linux, and Windows.Dependencies of BICePspymbar>= 4.0.1mdtraj>= 1.5.0matplotlib >= 2.1.2numpy >= 1.14.0multiprocessingViewthe workflow of BICePs.BICePs is research software. If you make use of BICePs in scientific publications, please cite it.To get started, seebiceps/releasesfor the latest version of BICePs.
Package: bicks
BICKS is a solver to find BICs in 1D PhC slab. Give the properties of a PhC slab and you can get the BICs.OutputBICKS can find BICs in the both high direction lines.In the periodical direction:and in the other direction:InstallEasiest way:pipinstallbicksTry this in your terminal or git bash to install bicks :gitclonehttps://github.com/PMRG-LE707/bicks.gitExampleThere are a lot examples in./docs/examples/which can help you quick-start.DocumentationSeehereto get help about classes and functions in bicks.
Package: biclustlib
biclustlibThe package is an extension ofbiclustlibPython library by Victor Alexandre Padilha.It is highly recommended to see the original repository first.The goal of this package is to create a unified biclustering framework for performing research on gene expression data and comparing different biclustering algorithms and measures.Distributed under GPLv3 license.Installationpip install biclustlibYou must also installRand the following R packages:biclustisa2Benchmarking exampleimportmultiprocessingimportpandasaspdfromsklearn.preprocessingimportKBinsDiscretizerfrombiclustlib.algorithmsimport*frombiclustlib.algorithms.wrappersimport*frombiclustlib.benchmarkimportGeneExpressionBenchmark,Algorithmfrombiclustlib.benchmark.dataimportload_tavazoie,load_prelicdefdiscretize_data(raw_data:pd.DataFrame,n_bins:int=2)->pd.DataFrame:returnpd.DataFrame(KBinsDiscretizer(n_bins,encode='ordinal',strategy='kmeans').fit_transform(raw_data),index=raw_data.index).astype(intifn_bins>2elsebool)if__name__=='__main__':data=load_tavazoie()n_biclusters=10reduction_level=10discretion_level=30data_dis=discretize_data(data,discretion_level)data_bin=discretize_data(data)setup=[Algorithm('CCA',ChengChurchAlgorithm(n_biclusters),data),Algorithm('xMotifs',RConservedGeneExpressionMotifs(n_biclusters),data_dis),Algorithm('BiBit',BitPatternBiclusteringAlgorithm(),data_bin),Algorithm('Bimax',RBinaryInclusionMaximalBiclusteringAlgorithm(n_biclusters),data_bin),Algorithm('LAS',LargeAverageSubmatrices(n_biclusters),data),Algorithm('Plaid',RPlaid(n_biclusters),data),Algorithm('Spectral',Spectral(n_clusters=data.shape[1]//2),data+abs(data.min().min())+1),]withmultiprocessing.Pool()aspool:tavazoie_benchmark=GeneExpressionBenchmark(algorithms=setup,raw_data=data,reduction_level=reduction_level).run(pool)tavazoie_benchmark.generate_report()tavazoie_benchmark.perform_goea()tavazoie_benchmark.generate_goea_report()
Package: bicop
Introductionbicopis a python library to process ISC bind-style configuration files.
These are nested structures that look like this:datasource1 {
    server     "server1.your.domain";
    username   "client";
    password   "secret";
    extra {
        isolation "full";
    };
};

tables {
    "users";
    "groups";
};ParsingParsing is trivial using the ‘’parse’’ method:from bicop import parse
parse("/etc/bind/named.conf")This returns a standard python dictionary with all data read from the
file. Entries in the dictionary can be other dictionaries or lists.MergingA common need is to be able to support default values for configurations
or to handle configuration at multiple levels with priorities, for example
a uer configuration overriding entries from the system-wide configuration.
To support this bicop has a utility method that can merge dictionaries. You
can use it like this:from bicop import parse
from bicop import merge

configuration=parse("/etc/application.conf")
userconfig=parse("/home/user/.application")
merge(configuration, userconfig, overwrite=True)Easy access for nested dictionariesConfiguration files in this format can have deeply nested structures. Accessing
those using standard python dictionaries is a slightly cumbersone. To make
this a bit more pleasant on the eyes you can use the NestedDict wrapper:from bicop import parse
from bicop import NestedDict

configuration=NestedDict(parse("/etc/application.conf"))
print "Your signature is: %s" % configuration["profiles/user/signature"]Changes1.0rc2 - August 2, 20009Add an optional dictclass parameter to the parse method. This can be
used to use alternative dictionary types, most typically ordered
dictionaries.Drop dependency on nose to run tests.Use ez_setup to automatically install setuptools if needed.
Package: bicti
Simple startup tool for docker containers.bicti is intended as the entrypoint of a container,
and provides a few helpers for systems that may require several services
(for instance, fastcgi and nginx and cron and logrotate).Its features include:Declarative list of supported commandsLaunch all demons or only a few onesDrop into a shell insteadDepenciesbicti is written in Python; it supports all versions from 2.6 onwards.
It also relies onrunit(http://smarden.org/runit/) for daemon management.SetupIn your dockerfile, add:RUNapt-get-qqyinstallrunitpythonpython-pipRUNpipinstallbicti&&ln-s/sbin/bicti`whichbicti`ADD./bicti.ini/etc/bicti.iniRUN/sbin/bicti--setupENTRYPOINT"/sbin/bicti"This will:Retrieve bicti and its dependenciesLoad yourbicti.iniconfiguration file (expected at/etc/bicti.ini)Setup all daemon startup scripts in/etc/runitDeclare bicti as your entry point.Core conceptsBeyond a few command-line flags, most of bicti’s job is in setting up the configuration
forrunit.Upon startup, bicti will:Load its configuration file (/etc/bicti.ini)Setuprunitto start the declared servicesTransfer control torunit, which handles daemon auto-restart, orphan process reaping, etc.Usage$dockerrunmy/image--helpusage:bicti.py[--configCONFIG][--rootROOT][-h][--setup][--shell[SHELL]][--all][SERVICE[SERVICE...]]Bicti,thedockerinnersetup.positionalarguments:SERVICEServicestostart(validoptions:cron,uwsgi)optionalarguments:--configCONFIG,-cCONFIGReadconfigurationfromCONFIG--rootROOTUsepathsrelativetoROOT-h,--helpShowthishelpmessageandexit--setupSetuptheservicefiles--shell[SHELL]Droptoashell(default=/bin/bash)--allStartallservicesConfiguration file:[bicti]; Run before any service is startedsetup=/sbin/my-image-setup; Run once all services have been stoppedteardown=/sbin/my-image-cleanup; One section per service[cron]; Actual command to runcommand=/usr/bin/cron; Require another service to be started firstafter=syslog[uwsgi]command=/usr/bin/uwsgi; Command to run before starting the servicesetup_command=mkdir /var/log/uwsgi; Special uid/giduid=www-datagid=www-data
Package: bidask
Efficient Estimation of Bid-Ask Spreads from Open, High, Low, and Close PricesImplements an efficient estimator of bid-ask spreads from open, high, low, and close
prices as described inArdia, Guidotti, & Kroencke (2021).InstallationInstall this package with:pipinstallbidaskUsageImport the estimator:frombidaskimportedgeArguments:edge(open,high,low,close,sign=False)fielddescriptionopenArray-like vector of open priceshighArray-like vector of high priceslowArray-like vector of low pricescloseArray-like vector of close pricessignWhether signed estimates should be returnedThe input prices must be sorted in ascending order of the timestamp.The output value is the spread estimate. A value of 0.01 corresponds to a spread of 1%.Exampleimportpandasaspdfrombidaskimportedgedf=pd.read_csv("https://raw.githubusercontent.com/eguidotti/bidask/main/pseudocode/ohlc.csv")edge(df.Open,df.High,df.Low,df.Close)Cite asArdia, David and Guidotti, Emanuele and Kroencke, Tim Alexander, "Efficient Estimation of Bid-Ask Spreads from Open, High, Low, and Close Prices". Available at SSRN:https://ssrn.com/abstract=3892335A BibTex  entry for LaTeX users is:@unpublished{edge2021,author={Ardia, David and Guidotti, Emanuele and Kroencke, Tim},title={Efficient Estimation of Bid-Ask Spreads from Open, High, Low, and Close Prices},year={2021},note={Available at SSRN}url={https://ssrn.com/abstract=3892335}}
Package: bidbot
The Bidding GameThis is a client-side bot for the "bidding game".RulesThis game consists of two people (or bots) that are "bidding" for a high value item, usually described as a bottle of scotch.There are 11 "places" between each player with the bottle of scotch sitting in the middle. If a player wins a round, the bottle
of scotch moves towards the player by one place. If the bottle gets all the way to the end (slot 0 or 10) then that player
wins the bottle. If by the end of 10 rounds neither player wins, the game is considered a draw.To win a round, each player must secretly bid some amount of money. The player with the biggest bid wins that round, and
the bottle of scotch moves one position towards them. Each player starts with $100, and must bid in $1 increments. The
player who wins the round has their bid deducted from their total, and the player who lost keeps their bid.In the case of both bids being equal, the player with "draw advantage" wins the round. "Draw advantage" starts with player A,
and every time there is a draw, "draw advantage" is switched to the other player.Finally, you must bid at least $1, unless you're out of money in which case you may bid $0.Make sure you include
this as part of your bot or your bids will be invalid and the game will be abandoned.Making A BotThe following is necessary to make a bot:Install this library. This is easily done by running:pip3 install bidbotExtend the BidBot object.Connect to a server.Example bot:The following is  full example of a bot. Note that the only thing a play can really do is pick a bid, you only
need to override one object. The following is a bot that randomly picks an amount to play.frombidbot.BidBotimportBidBotfrombidbot.GameStateimportGameStatefrombidbot.BotClientimportconnectimportrandomclassRandomBot(BidBot):defget_bid(self,game_state:GameState):ifgame_state.my_money<=1:returngame_state.my_moneyelse:returnrandom.randrange(1,game_state.my_money)defmain():username="your_username"bot=RandomBot(username)host="your_sever.hostname.com"port=8080connect(host,port,username,bot)if__name__=="__main__":main()GameStateThere's lots of information that can be used to assist you in picking a bid. The following fields are some useful ones:game_state.self.opponent_username- The opponents username.game_state.self.player_identifier- Determines if we are GameState.PLAYER_A or GameState.PLAYER_Bgame_state.opponent_money- The amount of money the opponent has left.game_state.my_money- The amount of money your bot has left.game_state.bottle_position- The current bottle position.game_state.opponents_bids- A list of the bids the opponent has made up until now.game_state.my_bids- A list of bids that your bot has made up until now.game_state.start_money- The amount of money the game was started with. Typically, this is $100.game_state.rounds_won- The number of rounds that have been won.game_state.rounds_lost- The number of rounds that have been lost.
Package: bidcap
bidcapBenchmark Image Dataset Collection And PreprocessingImage datasets incorporated so farMNIST dataset and its variants - 12000 train, 50000 testMB: MNIST basic datasetMBI: MNIST background image - A patch from a black and white image was used as the background for the digit imageMDRBI: MNIST digits with rotation and background image - The perturbations used in MRD and MBI were combined.MRB: MNIST random background - A random background was inserted in the digit imageMRD: MNIST rotated digits - The digits were rotated by an angle generated uniformly between 0 and 360 radians.CONVEX dataset - 8000 train, 50000 testUsage of the packagedownload the datasetsDownload the datasets and put the files under the root directory of your project as shown in the following picture.Load the datasets# import the loader toolfrombidcap.utils.loaderimportImagesetLoader# import mb. Pass the dataset name described above as the first parameterdata=ImagesetLoader.load('mb')# training imagesdata.train['images']# training labelsdata.train['labels']# test imagesdata.test['images']# test labelsdata.test['labels']
Package: bidfx-api
BidFX Public API for PythonApricingAPI that connects to the BidFX trading platform
to subscribe to realtime FX pricing. The API supports:FX request for stream (RFS) pricingFX request for quote (RFQ) pricingQuick startInstallationpipinstallbidfx-apiAPI docsRead the documentationhere.Python versionThe API is compatible with Python 3.6 and greater.
If you do not have Python, please install the latest 3.x version frompython.orgor refer to theInstalling Pythonsection
of the Hitchhikerâ€™s Guide to Python.Alternative APIsIf you prefer not to code in Python, you can read about the complete BidFX API range, and their different capabilities,
atBidFX API Overview.
Package: bidgely
BidgelyA Python library for getting historical and forecasted usage/cost from utilities that use Bidgely such as Hydro Ottawa.Supported utilities:Hydro OttawaPossible Supports:BC HydroNS PowerHydro OnePublic Service Electric and Gas (PSE&G)MorehereSupport a new utilityTo add support for a new utility that uses the Bidgely NA API (you can tell if the energy dashboard of your utility makes network requests to naapi-read.bidgely.com in the network tab of your browser's developer tools) add a file similar tohydroottawa.pyName the file after the utility , e.g. hydroottawa.py for Hydro Ottawa or bchydro.py for BC Hydro.Since this library is planned to be used by Home Assistant, then perhttps://github.com/home-assistant/architecture/blob/master/adr/0004-webscraping.mdwe cannot have a dependency on a headless browser and we can only parse HTML during login.An exception is made for the authentication phase. An integration is allowed to extract fields from forms. To make it more robust, data should not be gathered by scraping individual fields but instead scrape all fields at once.ExampleSeedemo.pyThank youInspired by opower by@tronikosAsync pycognito sign in from@dotKrad
Package: bidimensional
BidimensionalThis package contains a collection of useful classes and functions for working with 2D geometry in Python.Objectives and contributionsThis package has three fundamental bases:Simplicity- The package is designed to be simple and easy to use, with a minimalistic approach to the implementation of its features.Rich documentation- The package is fully documented, with a detailed description of its features and their usage.Performance- The package is designed to be as fast as possible, mainly using simple algebraic operations instead of complex calculations.Any contribution is welcome as long as it follows the objectives of the package. For more information, refer to thecontributing guidelines.FeaturesThe following features are currently implemented:Coordinate- A class for representing a 2D coordinate. It can be used to represent a point in the plane, or a vector from the origin. It provides with multiple access methods, as well as a set of useful methods for performing operations with other coordinates.polygons.Triangle- A class for representing a triangle in the plane. Contains several methods that can be used to compute its area, perimeter and relevant centers, as well as determining relevant properties of triangles (e.g. if they are equilateral, isosceles, etc.).functions.Spline- A class for representing a spline function. It can be used to interpolate a set of points in the plane and to compute the value of the function at any given point in between.operations- A module that contains relevant functions for performing operations with coordinates and triangles. It provides with functions for computing the distance between two points, the area of a triangle, the midpoint of a segment, etc.InstallationThe installation process is performed via PyPI (Python Package Index), so the package can be installed using thepipcommand.pipinstallbidimensionalRefer to thePyPI releasefor more information about how to install the package in your system.UsageOnce the package has been installed, its modules can be easily imported into custom programs via theimportstatement.ExamplesComposition of a small triangle out of the midpoints of the sides of a larger triangle, computation of the circumcircle of the inner triangle and figure plotting.importbidimensional.operationsasopimportmatplotlib.pyplotaspltfrombidimensionalimportCoordinatefrombidimensional.polygonsimportTriangleouter_triangle=Triangle(Coordinate(0,0),Coordinate(1,0),Coordinate(0,1))inner_triangle=Triangle(op.midpoint(outer_triangle.a,outer_triangle.b),op.midpoint(outer_triangle.b,outer_triangle.c),op.midpoint(outer_triangle.c,outer_triangle.a))outer_triangle.plot(color="darkorange",lw=2)inner_triangle.plot()plt.gca().add_patch(plt.Circle(inner_triangle.circumcenter,inner_triangle.circumradius,color="darkblue",fill=False,lw=2))plt.axis("equal")plt.grid()plt.show()
Package: bidobe
Binary-doppler-beamingThis software generates a light curve of a binary system which is caused by the photometric beaming. For more details seearXiv:0708.2100. You can set up any configuration of a binary system seen from Earth.InstallationTo install the package please type from the command line:$sudopip3installbidobeor alternatively:$gitclonehttps://github.com/pbrus/binary-doppler-beaming
$cdbinary-doppler-beaming
$sudopython3setup.pyinstallUsageAll you need are thedoppler_beaming.pyscript and thebinary.conffile. Edit the last one and configure your own binary system (see comments inside this file to find out which units are used):[OBJECTS]mass1=1mass2=2temperature1=6000temperature2=8000radius1=1.0radius2=1.5distance=1000[ORBITS]sum_major_axis=8e10eccentricity=0.4longitude_node=70.0inclination=60.0periastron_argument=110.0...Now you can run thedoppler_beaming.py:$python3doppler_beaming.pyThe main modulebidobe(binarydopplerbeaming) provides the interface to display, save to files and animate orbits, radial velocities and light curves. Moreover, it allows to convertSIunits from and to astronomical units. For example:orbit1_position=orbit1.convert_m_to_au(orbit1_position)converts position in meters to position inAUs. The following commands:plot_projected_orbits(orbit1_position,orbit2_position,"AU","AU")plot_projected_orbits(orbit1_position,orbit2_position,"AU","AU","orbits.eps")animate_projected_orbits(orbit1_position,orbit2_position,"AU","AU")can be used to display orbits projected on the sky, save them toorbits.epsfile and animate them on the screen, respectively.I encourage to visit my website to see more detailed description of this project. The current link can be found on myGitHub profile.LicenseBinary-doppler-beamingis licensed under theMIT license.
Package: bidq
pybidqPython SDK for bidqUsageimportasynciofrombidqimportBidQasyncdefsetup_worker():client=awaitBidQ.create()@client.worker("add")defadd(x,y):returnx+yawaitclient.serve()asyncdefsend_job():client=awaitBidQ.create()jid=awaitclient.submit("add",{"x":1,"y":2},0.2)try:print(awaitclient.get(jid))exceptExceptionase:print(e)awaitclient.close()# asyncio.run(send_job())asyncio.run(setup_worker())
Package: bids2cite
bids2citeCreate a citation file for a BIDS dataset.Can also be used to update references, authors and add license to a dataset.Installationgitclonehttps://github.com/Remi-Gau/bids2cite.gitcdbids2cite
pipinstall.For developerspipinstall.[dev]Basic tests can be run with:maketestmaketest-cliUsageThe most basic usage is:bids2citepath_to_bids_datasetAn example of call with all the options:bids2cite"tests/bids"\--keywords"foo, bar, me"\--description"this is the description of my dataset"\--authors_file"inputs/authors.tsv"\--skip-promptfalse\--verbosityINFO--keywordsand--descriptionallow you to pass keywords and description to
add to the citation file.--skip-promptis set tofalse(default) to prompt you for information to add
to the citation file.--authors_filepoints to a TSV file containing potential authors to add
citation file. This can be useful if you need to have a single file to keep
track of several lab members and only pick the relevant ones to add to a given
dataset.This TSV file must at least havefirst_nameandlast_namecolumns, but can
also includeORCIDandaffiliationcolumns.first_namelast_nameORCIDaffiliationRémiGau0000-0002-1535-9767UCLouvainMohamedRezk0000-0002-1866-8645UCLouvainThere is a sample TSV in theinputs folder.Type the following for more info on how to run it:bids2cite--help
Package: bids2table
bids2tablebids2table is a library for efficiently indexing and querying large-scale BIDS neuroimaging datasets and derivatives. It aims to improve upon the efficiency ofPyBIDSby leveraging modern data science tools.bids2table represents a BIDS dataset index as a single table with columns for BIDS entities and file metadata. The index is constructed usingArrowand stored inParquetformat, a binary tabular file format optimized for efficient storage and retrieval.InstallationA pre-release version of bids2table can be installed withpipinstallbids2tableThe latest development version can be installed withpipinstallgit+https://github.com/childmindresearch/bids2table.gitDocumentationOur documentation ishere.Exampleimportpandasaspdfrombids2tableimportbids2table# Load in memory as pandas dataframedf=bids2table("/path/to/dataset")# Load in parallel and stream to disk as a Parquet datasetdf=bids2table("/path/to/dataset",persistent=True,workers=8)Seeherefor a more complete example.Performancebids2table significantly outperforms bothPyBIDSandancpBIDSin terms of indexing run time, index size on disk, and query run time.Indexing performanceIndexing run time and index size on disk for theNKI Rockland Sampledataset. See theindexing benchmarkfor more details.IndexNum workersRun time (s)Index size (MB)PyBIDS11618448ancpBIDS1465--bids2table14024.02bids2table853.23.84bids2table6410.74.82Query performanceQuery run times for theChinese Color Nest Projectdataset. See thequery benchmarkfor more details.IndexGet subjects (ms)Get BOLD (ms)Query metadata (ms)Get morning scans (ms)PyBIDS135012.36.5334.3ancpBIDS30.619.2----bids2table0.0460.3460.3120.352