Saravanan666/pypi-org huggingface dataset:
Package: bin-package-manager
bin package managerEnglish |简体中文Bin package manager (BPM) is a Github release-based package manager that allows users to install and manage binaries from any Github release.BPM is currently supported on Linux and Windows, python >= 3.10.[!CAUTION]
Risk Warning: BPM on Linux may damage your computer. By using BPM to install software, you accept this risk and trust third-party Github release packagers.Why use it?In non-rolling release Linux distributions, the version of softwares in official source are often too low to use some new features.Rolling distributions, such as Archlinux, are also unable to install software from the AUR as root.A common way to manage packages on Windows is scoop, but it requires the packager to maintain a "manifest" list.InstallationBPM needs to be installed to root user.pipLinuxsudopipinstallbin-package-manager--break-system-packages
sudobpmNote the risk of potentially breaking system packages.Windowspipinstallbin-package-manager
bpmpipxYou can use pipx to install BPM.sudopipxinstallbin-package-managerpipx will only install for the current user, sosudois required. Alternatively, you can track onthis issueand use other methods mentioned there.Source codeIf you don't want to use pipx, you can also download and use the source code.BPM requiresthese libs, please install them manually.gitclonehttps://github.com/lxl66566/bpm.gitcdbpm
python3-mbpm# or use poetry to install dependencies and run: `poetry install && poetry run python -m bpm`UsageInstall:bpm i <package>Runbpm -hfor more help.How it worksLinuxBPM automatically determines the file structure in the asset and installs it to the appropriate location on the system. The current installation is like:install binarymerge thelib,include,share,man,bindirectories into the systeminstall completionsBPM automatically adds the.oldsuffix to existing files to avoid overwrite. The.oldfiles will be restored in uninstalling.WindowsBPM downloads asset into%userprofile%/bpm/app/<name>and creates shortcuts and cmd runner for the executables to%userprofile%/bpm/bin, which is added to%path%.Developgitclonehttps://github.com/lxl66566/bpm.gitcdbpm
poetryinstall
poetryrunpython-munittestbpm/**/*.py# run testsTODOno pre releasetry installwindows support
Package: binpacker
binpacker ======Generic Bin Packing Problem Solver.Given a set of items with weight information and capacity of a bin,
Binpacker determines which items can fit in the bin with that
capacity and continues to pack all items in new bins in a way that
it will utilize the space of each bin. In the other word, Binpacker
can be used to determine what is the minimum number of bins we can
use to pack all items with different weights.RequirementsPython 3.4 (tested)GoalThe ultimate goal of this library is to provide a generic interface for
solving the Bin Packing problem for variety of applications.Code sampleLets say, given the capacity (11) of a bin and a list of packages with
different weights, we would like to load and unload the packages in a
way that it utilizes the space of each bin.importtimefrombinpacker.binpackerimportBinpackerfrombinpacker.binpackerimportItempacker=Binpacker(11)packer.items=[Item('A',4),Item('B',1),Item('C',2),Item('D',6),Item('E',9),Item('F',3),Item('G',7),Item('H',2),Item('I',5)]j=0whileTrue:packer.pack_items()fori,xinenumerate(packer.bins):print('Bin ({}%){}:{}'.format(x.utilization,i,[i.nameforiinx.get_items()]))print('----------------------------------')packer._items.append(Item('Z{}'.format(i),2))j+=1time.sleep(3)output:Bin(100.0%)0:['H','C','F','A']Bin(100.0%)1:['I','D']Bin(90.91%)2:['B','E']Bin(63.64%)3:['G']----------------------------------Bin(100.0%)0:['H','C','F','A']Bin(100.0%)1:['I','D']Bin(90.91%)2:['B','E']Bin(81.82%)3:['Z0','G']----------------------------------Bin(100.0%)0:['H','C','F','A']Bin(100.0%)1:['I','D']Bin(90.91%)2:['B','E']Bin(100.0%)3:['Z0','G','Z1']----------------------------------Bin(100.0%)0:['H','C','F','A']Bin(100.0%)1:['I','D']Bin(90.91%)2:['B','E']Bin(100.0%)3:['Z0','G','Z1']Bin(18.18%)4:['Z2']----------------------------------Bin(100.0%)0:['H','C','F','A']Bin(100.0%)1:['I','D']Bin(90.91%)2:['B','E']Bin(100.0%)3:['Z0','G','Z1']Bin(36.36%)4:['Z2','Z3']----------------------------------Bin(100.0%)0:['H','C','F','A']Bin(100.0%)1:['I','D']Bin(90.91%)2:['B','E']Bin(100.0%)3:['Z0','G','Z1']Bin(54.55%)4:['Z2','Z3','Z4']Note that (xxx%) is the percentage of fullnessContributors
Package: binpacking
This package contains greedy algorithms to solve two typical bin packing
problems, (i) sorting items into a constant number of bins, (ii) sorting
items into a low number of bins of constant size. Here’s a usage example>>>importbinpacking>>>>>>b={'a':10,'b':10,'c':11,'d':1,'e':2,'f':7}>>>bins=binpacking.to_constant_bin_number(b,4)# 4 being the number of bins>>>print("===== dict\n",b,"\n",bins)=====dict{'a':10,'b':10,'c':11,'d':1,'e':2,'f':7}[{'c':11},{'b':10},{'a':10},{'f':7,'e':2,'d':1}]>>>>>>b=list(b.values())>>>bins=binpacking.to_constant_volume(b,11)# 11 being the bin volume>>>print("===== list\n",b,"\n",bins)=====list[10,10,11,1,2,7][[11],[10],[10],[7,2,1]]Consider you have a list of items, each carrying a weightw_i.
Typical questions areHow can we distribute the items to a minimum number of binsNof
equal volumeV?How can we distribute the items to exactlyNbins where each
carries items that sum up to approximately equal weight?Problems like this can easily occur in modern computing. Assume you have
to run computations where a lot of files of different sizes have to be
loaded into the memory. However, you only have a machine with 8GB of
RAM. How should you bind the files such that you have to run your
program a minimum amount of times? This is equivalent to solving problem
1.What about problem 2? Say you have to run a large number of
computations. For each of the jobs you know the time it will probably
take to finish. However, you only have a CPU with 4 cores. How should
you distribute the jobs to the 4 cores such that they will all finish at
approximately the same time?The package provides the command line tool “binpacking” using which one
can easily bin pack csv-files containing a column that can be identified
with a weight. To see the usage enter$binpacking-hUsage:binpacking[options]Options:-h,--helpshowthishelpmessageandexit-fFILEPATH,--filepath=FILEPATHpathtothecsv-filetobebin-packed-VV_MAX,--volume=V_MAXmaximumvolumeperbin(constantvolumealgorithmwillbeused)-NN_BIN,--n-bin=N_BINnumberofbins(constantbinnumberalgorithmwillbeused)-cWEIGHT_COLUMN,--weight-column=WEIGHT_COLUMNinteger(orstring)givingthecolumnnumber(orcolumnnameinheader)wheretheweightisstored-H,--has-headerparsethisoptionifthereisaheaderinthecsv-file-dDELIM,--delimiter=DELIMdelimiterinthecsv-file(use"tab"fortabs)-qQUOTECHAR,--quotechar=QUOTECHARquotecharacterinthecsv-file-lLOWER_BOUND,--lower-bound=LOWER_BOUNDweightsbelowthisboundwillnotbeconsidered-uUPPER_BOUND,--upper-bound=UPPER_BOUNDweightsexceedingthisboundwillnotbeconsideredInstall$pipinstallbinpackingExamplesIn the repository’s directorycdexamples/binpacking-fhamlet_word_count.csv-V2000-H-ccount-l10-u1000binpacking-fhamlet_word_count.csv-N4-H-ccountin Pythonimportbinpackingb={'a':10,'b':10,'c':11,'d':1,'e':2,'f':7}bins=binpacking.to_constant_bin_number(b,4)print("===== dict\n",b,"\n",bins)b=list(b.values())bins=binpacking.to_constant_volume(b,11)print("===== list\n",b,"\n",bins)
Package: bin-packing-problem
# Bin Packing ProblemThis library is a grouping of 1D approximate solutions for the BPP  There is also a generic function to create variants.## Example`pythonimport randomfrom binpackp import NumberBin, Fitbin_size = random.randint(10,100)fit_these = [random.randint(1, bin_size) for _ in range(1000)]generic_results = Fit.fit(NumberBin, bin_size, fit_these)first_fit_results = Fit.ff(NumberBin, bin_size, fit_these)print("General Function: ", generic_results)print("First Fit Function: ", first_fit_results)
Package: bin-parser
This library provides general binary file parsing by interpreting documentation
of a file structure and data types. By default, it supports basic data types
like big-endian and little-endian integers, floats and doubles, variable length
(delimited) strings, maps and bit fields (flags) and it can iterate over sub
structures. Other data types are easily added.The file structure and the types are stored in nested dictionaries. The
structure is separated from the types, this way multiple file formats using the
same types (within one project for example) can be easily supported without
much duplication.The design of the library is such that all operations can be reversed. This
means that fully functional binary editing is possible using this
implementation; first use the reader to convert a binary file to a serialised
dictionary representation, this representation is easily edited using a text
editor, and then use the writer to convert back to binary.This idea is implemented in two languages; Python and JavaScript. All main
development is done in Python. We chose YAML as our preferred serialised
dictionary format, but other serialisation formats (JSON for example) can be
used too.Please seeReadTheDocsfor the latest documentation.
Package: binpickle
BinPickle - efficient binary pickled dataThis package uses the new Pickle Protocol 5 in Python 3.8 (or itspickle5backport)
to efficiently serialize large objects, particularly from scientific Python packages,
to an on-disk format.  This format is designed to support two use cases:Serializing data-intensive statistical models in a memory-mappable format so
multiple processes can share the same (read-only) model memory.Serializing data-intensive statistical models with good compression for long-term
storage and cross-machine transportation.BinPickle does this by using Pickle 5's out-of-band buffer serialization support to
write buffers uncompressed and page-aligned for memory mapping (use case 1) or with
per-buffer efficient compression with libraries like Blosc (use case 2).Format StabilityWe donotyet guarantee the stability of the BinPickle format.  We will avoid gratuitous changes,
but BinPickle 1.0 will be the first with a stability guarantee.AcknowledgementsThis material is based upon work supported by the National Science Foundation under
Grant No. IIS 17-51278. Any opinions, findings, and conclusions or recommendations
expressed in this material are those of the author(s) and do not necessarily reflect
the views of the National Science Foundation.  This page has not been approved by
Boise State University and does not reflect official university positions.
Package: binprism
# BinPrism
Tools for fitting linear combinations of continuous basis functions to match binned data.Often, data from continuous variables are placed into discrete bins.
BinPrism fits continuous profiles to match these bins, allowing for the ability to produce clean visualizations, re-aggregate data into differently-sized bins, and simulate random values folling a continuous distribution matching the original data. Like a prism separating light into different colors, BinPrism takes in binned data and separates it into simple waves, saving the contribution of each wave to memory. Presently, BinPrism only works for periodic data (such as daily or yearly patterns), but it is hoped that in the future more domains will be supported.
Package: binr
binrDeveloper GuideSetup# create conda environment$mambaenvcreate-fenv.yml# update conda environment$mambaenvupdate-nbinr--fileenv.ymlInstallpipinstall-e.# install from pypipipinstallbinrnbdev# activate conda environment$condaactivatebinr# make sure the binr package is installed in development mode$pipinstall-e.# make changes under nbs/ directory# ...# compile to have changes apply to the binr package$nbdev_preparePublishing# publish to pypi$nbdev_pypi# publish to conda$nbdev_conda--build_args'-c conda-forge'$nbdev_conda--mambabuild--build_args'-c conda-forge -c dsm-72'UsageInstallationInstall latest from the GitHubrepository:$pipinstallgit+https://github.com/dsm-72/binr.gitor fromconda$condainstall-cdsm-72binror frompypi$pipinstallbinrDocumentationDocumentation can be found hosted on GitHubrepositorypages. Additionally you can find
package manager specific guidelines oncondaandpypirespectively.
Package: binsdpy
binsdpy - binary similarity and distance measuresPython implementation of binary similarity (see [1]) and distance measures (see [2]). Thebitsets(immutable ordered set data type) andnumpy.ndarrayare suported as feature vectors.ExampleExample based onbitsets:frombitsetsimportbitsetfrombinsdpy.similarityimportjaccardfrombinsdpy.distanceimporteuclidColors=bitset("Colors",("red","blue","green","yellow"))a=Colors.frommembers(["red","blue"])b=Colors.frommembers(["red","yellow"])jaccard(a,b)# > 0.3333333333333333euclid(a,b)# > 1.4142135623730951Example based onnp.ndarray:importnumpyasnpfrombinsdpy.similarityimportjaccardfrombinsdpy.distanceimporteuclida=np.array([1,1,0,0],dtype=bool)b=np.array([1,0,0,1],dtype=bool)jaccard(a,b)# > 0.3333333333333333euclid(a,b)# > 1.4142135623730951InstallationPackage is avaliable in alpha version viapip.$pipinstallbinsdpyDependenciesbinsdpy requires:Python (>= 3.6)bitsetnumpyReference[1] Brusco, M., Cradit, J. D., & Steinley, D. (2021). A comparison of 71 binary similarity coefficients: The effect of base rates. Plos one, 16(4), e0247751.https://journals.plos.org/plosone/article?id=10.1371/journal.pone.0247751[2] Choi, S. S., Cha, S. H., & Tappert, C. C. (2010). A survey of binary similarity and distance measures. Journal of systemics, cybernetics and informatics, 8(1), 43-48.http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.352.6123&rep=rep1&type=pdf
Package: binsize
Binsize toolTool for analyzing the sizes of symbols in binaries.It can be used to find out which symbols are taking up the most space in a binary.It requiresbloatyandnmtools to be installed.It analyzes the.elffile and optionally also the.mapfile from the binary creation process.Tool basic usageInstallable bypip install binsize- seePyPI.Installing this package createsbinsizecommand, which has a lot of subcommands seeable bybinsize --help. For example$binsizegetfirmware.elf-d
$binsizecomparefirmware.elfother_firmware.elf
$binsizetreefirmware.elf--helpcan be used even on the subcommands, for examplebinsize get --help- to see all available options.Result will be usually printed into terminal, unless specifying--outputoption which some commands support.Setting root directoryTo resolve all the files properly, the project's root directory needs to be set correctly.There are couple of possibilities how to do it.In the end, all of them are changing therootvalue insettings.json, from where everything else gets the value. It needs to be an absolute path.settings.jsonwill be created in a user's home directory, based onplatformdirslibrary (~/.config/binsize/settings.jsononlinux).ManuallyJust modifying therootin thesettings.jsonfile.Via environmental variableBINSIZE_ROOT_DIRenv variable is checked and when not empty, it will set the root directory.e.g.BINSIZE_ROOT_DIR=/home/user/project binsize tree /path/to/file.elfVia CLI argumentbinsizeaccepts-r / --root-dirargument, which can be used to set the root directory.It has lower priority than the environmental variable.e.g.binsize -r /home/user/project tree /path/to/file.elfVia exposed functionbinsizeexposesset_root_dirfunction, which can be called from anypythonscript.e.g.binsize.set_root_dir("/home/user/project")TODO: document all the CLI commands, exportable symbols, basic functioning, ways to extend it, etc.
Package: binsmooth
binsmoothPython implementation of "Better Estimates from Binned Income Data"Better Estimates from Binned Income Data: Interpolated CDFs and Mean-Matching
Paul T. von Hippel, David J. Hunter, McKalie Drown
Sociological Science
Volume 4, Number 26, Pages 641-655
2017Originally implemented in the R packagebinsmooth.Usagefrom binsmooth import BinSmooth

bin_edges = np.array([0, 18200, 37000, 87000, 180000])
counts = np.array([0, 7527, 13797, 75481, 50646, 803])
mean_estimate = 95000

bs = BinSmooth()
bs.fit(bin_edges, counts, m=mean_estimate)

# Print median estimate
print(bs.inv_cdf(0.5))InstallationInstall via pippip install binsmoothpypi pagehttps://pypi.org/project/binsmooth/ImprovementsBetter tail estimateby bounded optimisation rather than the adhoc search
method found in the R implementation.More precise inverse CDFby dynamically sampling the CDF. This is done
by sampling proportional to the steepness of the CDF i.e. sampling more
in areas where the CDF is steeper.WarningsResultsmay not exactly match Rbinsmoothbecause of a different approach
to estimating the tail (upper bound).Furthermore thefitmethod usesspline_type="PCHIP"by default, which is
scipy'sPchipInterpolator[1]. While the R implementation uses the spline
from [2], which can be mimicked by settingspline_type="HYMAN".References[1]: Fritsch, F. N. and Carlson, R. E. (1980).Monotone piecewise cubic interpolation. SIAM Journal on Numerical Analysis[2]: Hyman, J. M. (1983).Accurate monotonicity preserving cubic interpolation. SIAM Journal on Scientific and Statistical Computing
Package: binsreg
BINSREGBinscatter provides a flexible, yet parsimonious way of visualizing and summarizing large data sets and has been a popular methodology in applied microeconomics and other social sciences. Thebinsregpackage provides tools for statistical analysis using the binscatter methods developed in Cattaneo, Crump, Farrell and Feng (2022). binsreg implements binscatter least squares regression with robust inference and plots, including curve estimation, pointwise confidence intervals and uniform confidence band.binsqregimplements binscatter quantile regression with robust inference and plots, including curve estimation, pointwise confidence intervals and uniform conf idence band.binsglmimplements binscatter generalized linear regression with robust inference and plots, including curve estimation, pointwise confidence intervals and uniform confidence band.binstestimplements binscatter-based hypothesis testing procedures for parametric specifications of and shape restrictions on the unknown function of interest.binspwcimplements hypothesis testing procedures for pairwise group comparison of binscatter estimators.binsregselectimplements data-driven number of bins selectors for binscatter implementation using either quantile-spaced or evenly-spaced binning/partitioning. All the commands allow for covariate adjustment, smoothness restrictions, and clustering, among other features.AuthorsMatias D. Cattaneo (cattaneo@princeton.edu)Richard K. Crump (richard.crump@ny.frb.org)Max H. Farrell (maxhfarrell@ucsb.edu)Yingjie Feng (fengyingjiepku@gmail.com)Ricardo Masini (rmasini@princeton.edu)Websitehttps://nppackages.github.io/binsreg/Major UpgradesThis package was first released in Winter 2019, and had one major upgrade in Summer 2021.Summer 2021 new features include: (i) generalized linear models (logit, Probit, etc.) binscatter; (ii) quantile regression binscatter; (iii) new generic specification and shape restriction hypothesis testing function (now including Lp metrics); (iv) multi-group comparison of binscatter estimators; (v) generic point evaluation of covariate-adjusted binscatter; (vi) speed improvements and optimization. A complete list of upgrades can be foundhere.InstallationTo install/update use pippip install binsregUsagefrom binsreg import binsregselect, binsreg, binsqreg, binsglm, binstest, binspwcReplication:binsreg illustration,simulated data.DependenciesnumpypandasscipystatsmodelplotnineReferencesFor overviews and introductions, seeNP Packages website.Software and ImplementationCattaneo, Crump, Farrell and Feng (2023c):Binscatter Regressions.Working paper, prepared for Stata Journal.Technical and MethodologicalCattaneo, Crump, Farrell and Feng (2023a):On Binscatter.Working paper.Cattaneo, Crump, Farrell and Feng (2023b):Nonlinear Binscatter Methods.Working paper.
Package: binstarsolver
OverviewThe purpose of this project is to estimate physical quantities of an eclipsing, spectroscopic binary star system using observed quantities from photometry and spectroscopy.
The estimated physical quantities serve as input to a more complete numerical model such as that of Wilson-Devinney, c.f. chapter 7 of[1].
The model used in this project is a simple, spherical detached binary star model with no orbital eccentricity and no limb darkening.
The model is from chapter 7 of[2]and chapter 7 of[3].Input observed quantitiesRelative times of begin/end ingress/egress and mid-eclipse.Orbital period.Light levels during occultation (primary eclipse), transit (secondary eclipse), and outside of eclipse.Stellar radial velocities.Output estimated physical quantitiesOrbital inclination angle.Orbital radii.Stellar masses.Stellar radii.Ratio of stellar radiative fluxes.Ratio of stellar effective temperatures.Ratio of stellar luminosites.Examples and Q&A forumFor explanations of examples, please see thebinstarsolver GitHub wiki.For questions and discussion, please see thebinstarsolver Google group.Got a second for auser survey? I’d love your feedback! Thank you for being part of open science. (All survey responses are anonymous.)CitationsIf this code is useful to your academic research, please consider citing it by including this DOI link:http://dx.doi.org/10.5281/zenodo.16983Recent changes[v0.1.3] - 20150420T180000Created Google group, DOI for citations, CHANGELOG.rst, IPython Notebook examples.Fixed special cases where solver for inclination did not converge.[v0.1.2] - 20150123T172000Initial release to PyPI.References[1]Kallrath and Milone, 2007, Eclipsing Binary Stars: Modeling and Analysis[2]Budding, 2007, Introduction to Astronomical Photometry[3]Carroll and Ostlie, 2007, An Introduction to Modern Astrophysics
Package: binstore
Descriptionbinstore module with Bins C extension to implement storage of items based on value-based binning where binned value determines ordinal index into array where item is stored.   Supports item assignment and slice operations.Membersmin - float, minimum valuemax - float, maximum valuewidth - float, bin widthn_bins - int, number of bins = int((max - min) / width) + 1Methodsbin(value) - perform binning operation on value and returns corresponding bin ordinal value 0 <= n <= n_bins - 1put(value, item) - puts item into bin n = bin(value) and returns nget(value) - gets item from bin n = bin(value) and returns as tuple of (item, n)items() - returns items in bins as dict with left bin edge as key, item in bin as valueWhen performing binning:if value is <= min, bin(value) = 0if value is >= max, bin(value) = n_bins - 1if value is >= half the distance between left edge of bin n and left edge of bin n+1, then corresponding bin(value) = n+1, otherwise bin(value) = n.  e.g., for min = 0.0, max = 1.0, width = 0.01, bin(0.106) = 11, bin(0.103) = 10.Example:>>>b = Bins(min=0.0, max=1.0, width=0.01)
>>>for i in range(50):
>>>    b.put(i/100, {'i': i})
0
1
2
.
49
>>>b.get(0.005)
({'i': 1}, 1)
>>>b.get(0.000)
({'i': 0}, 0)
>>>b.get(0.004)
({'i': 0}, 0)
>>>b.get(0.103)
({'i': 10}, 10)
>>>b.get(0.106)
({'i': 11}, 11)
>>>b.put(0.106, {'foo': 'bar'})
11
>>>b[11]
{'foo': 'bar'}
>>>b[11] = {'bar': 'foo'}
>>>b[11]
{'bar': 'foo'}