Saravanan666/pypi-org huggingface dataset:
Package: b2gpopulate-v2.2
# b2gpopulateb2gpopulate is a tool to populate a
[Firefox OS](https://developer.mozilla.org/en-US/docs/Mozilla/Firefox_OS)
device with content.## RequirementsYour device must be running a build of Firefox OS with
[Marionette](https://developer.mozilla.org/docs/Marionette) enabled.## InstallationInstallation is simple:pip install b2gpopulateIf you anticipate modifying b2gpopulate, you can instead:git clone git://github.com/mozilla/b2gpopulate.git
cd b2gpopulate
python setup.py develop## RunningFor full usage details runb2gpopulate –help.
Package: b2h5py
b2h5pyprovidesh5pywith transparent, automatic optimized reading of n-dimensional slices ofBlosc2-compressed datasets. This optimized slicing leverages direct chunk access (skipping the slow HDF5 filter pipeline) and 2-level partitioning into chunks and then smaller blocks (so that less data is actually decompressed).Benchmarks of this technique show 2x-5x speed-ups compared with normal filter-based access. Comparable results are obtained with a similar technique in PyTables, seeOptimized Hyper-slicing in PyTables with Blosc2 NDim.UsageThis optimized access works for slices with step 1 on Blosc2-compressed datasets using the native byte order. It is enabled by monkey-patching theh5py.Datasetclass to extend the slicing operation. The easiest way to do this is:import b2h5py.autoAfter that, optimization will be attempted for any slicing of a dataset (of the formdataset[...]ordataset.__getitem__(...)). If the optimization is not possible in a particular case, normal h5py slicing code will be used (which performs HDF5 filter-based access, backed byhdf5pluginto support Blosc2).You may instead justimport b2h5pyand explicitly enable the optimization globally by callingb2h5py.enable_fast_slicing(), and disable it again withb2h5py.disable_fast_slicing(). You may also enable it temporarily by using a context manager:with b2h5py.fast_slicing():
    # ... code that will use Blosc2 optimized slicing ...Finally, you may explicitly enable optimizations for a given h5py dataset by wrapping it in aB2Datasetinstance:b2dset = b2h5py.B2Dataset(dset)
# ... slicing ``b2dset`` will use Blosc2 optimization ...BuildingJust install PyPA build (e.g.pip install build), enter the source code directory and runpyproject-buildto get a source tarball and a wheel under thedistdirectory.InstallingTo install as a wheel from PyPI, runpip install b2h5py.You may also install the wheel that you built in the previous section, or enter the source code directory and runpip install .from there.Running testsIf you have installedb2h5py, just runpython-munittest discover b2h5py.tests.Otherwise, just enter its source code directory and runpython-munittest.You can also run the h5py tests with the patchedDatasetclass to check that patching does not break anything. You may install theh5py-testextra (e.g.pip installb2h5py[h5py-test]and runpython-mb2h5py.tests.test_patched_h5py.
Package: b2sdk
B2 Python SDKThis repository contains a client library and a few handy utilities for easy access to all of the capabilities of B2 Cloud Storage.B2 command-line toolis an example of how it can be used to provide command-line access to the B2 service, but there are many possible applications (including FUSE filesystems, storage backend drivers for backup applications etc).DocumentationThe latest documentation is available onRead the Docs.InstallationThe sdk can be installed with:pip install b2sdkVersion policyb2sdk followsSemantic Versioningpolicy, so in essence the version number is MAJOR.MINOR.PATCH (for example 1.2.3) and:we increase MAJOR version when we make incompatible API changeswe increase MINOR version when we add functionality in a backwards-compatible manner, andwe increase PATCH version when we make backwards-compatible bug fixes (unless someone relies on the undocumented behavior of a fixed bug)Therefore when setting up b2sdk as a dependency, please make sure to match the version appropriately, for example you could put this in yourrequirements.txtto make sure your code is compatible with theb2sdkversion your user will get from pypi:b2sdk>=1.25.0,<2Release HistoryPlease refer to thechangelog.Developer InfoPlease see ourcontributing guidelines.
Package: b2tob3
Easier migration from Boostrap 2 to Boostrap 3b2tob3 is a command line tool to help migrate Web projects from bootstrap 2
to bootstrap 3 by performing a set of replacements that reflect bootstrap 3
class name changes.b2tob3 searches all files ending in .html, .htm, .css or .js in the current
directory and its subdirectories. You can specify the working directory with
thedoption likeb2tob3-d/path/to/dir.b2tob3 does not fully automate migration, but it takes away some of the tedious
work. Still, you’ll most likely need to perform manual fixes too.Installationpip install b2tob3Usagecd /project/html/
b2tob3Follow these steps to avoid frustration:Put your HTML/template files under version control, if they aren’t yet.Change to the directory with the files containing Boostrap 2 specific markup.Run the b2tob3 script once and only once.Review the changes with a diff tool suitable for the version control system you use.Perform the rest of the necessary changes manually.ContributingLet me know about bugs by postingan issue.Help reduce the manual work by improvingthe code.Write tests.ContributorsThanks to@demiurgfor adding more robust
replacements and command line options.
Package: b2tool
bbtool is a command line tool to manage BitBucketList of commands and –optionsauthlogin–username–passwordpullrequest__required options for all__–ownerOrganization or account on Bitbucket–repoRepository to connectlistalloldest–id True or False–branch True or Falseaccept–id Integer–message StringHow to useCommands$ b2tool command optionsAuthenticate on bitbucket$ b2tool auth login --username jesuejunior --password abc123List all pull requests$ b2tool pullrequest listall --owner jesuejunior --repo projectAList oldest pull requests with ID and branch$ b2tool pullrequest oldest --owner jesuejunior --repo projectAPrint only id of oldest pull requests$ b2tool pullrequest oldest --owner jesuejunior --repo projectA  --id TruePrint only branch of oldest pull requests$ b2tool pullrequest oldest --owner jesuejunior --repo projectA  --branch TrueAccept pull request with id 100$ b2tool pullrequest accept --owner jesuejunior --repo projectA  --id 100 --message 'Accept this pull request ok'
Package: b2upload
# BackBlaze Backuppushes the content of a folder (and all its subdirectories) to [backblaze](https://www.backblaze.com/)## Set upinstall b2uploadpip install b2uploadcreate a.backblazein your home directory
it should contain the following :` [backblaze] accountId =<your-account-id>applicationKey =<your-application-key>`## usageto upload all files and subfolders of the current directoryb2upload –bucket <bucket-name>to upload all files and subfolders of a specific directoryb2upload –bucket <bucket-name> –directory <absolute-path-to-dir>
Package: b2-utils
b2-utilsPassosEm caso de ser sua primeira vez publicando a lib no pipy é necessario um arquivo de configuração no home do seu computador com o nome .pypirc, para mais dethes consulte o topico no clickup (b2-utils-pypi).Antes de rodar o script para publicar a lib no pip é necessario subir a versão dela no pyproject.toml.[project]name="b2-utils"version="0.X.XX"Logo apos é necessario o rodar o script que compila as dependencias ./compile.shPor fim só publicar ser feliz.
Package: b3
Big Brother Bot B3 is a complete and total server administration package for online games. B3 is designed primarily to keep your server free from the derelicts of online gaming, but offers more, much more. With the stock configuration files, B3 will will keep your server free from offensive language, and team killers alike. A completely automated and customizable warning system will warn the offending players that this type of behavior is not allowed on your server, and ultimately kick, and or ban them for a predetermined time limit. B3 was designed to be easily ported to other online games. Currently, B3 is in production for the Call of Duty series, Urban Terror (ioUrT), etpro, World of Padman and Smokin’ Guns since these games are based on the Quake III Arena engine, conversion to any game using the engine should be easy. Plugins provide much of the functionality for B3. These plugins can easily be configured. An SDK will be provided to make your own plugins.
Package: b3buf
B3 = Better Binary BuffersB3 is a data serializer, it packs data structures to bytes & vice versa. It has:The schema power of protobuf, without the setup/compiler pain,The quick-start ease of json.dumps, but with support for datetimes,The compactness of msgpack, but without a large zoo of data types.With B3 you can fast-start with schema-less data (like json), and move to schemas (like protobuf) later & stay compatible. Or have ad-hoc json-like clients talk to rigorous protobuf-like servers without pain & suffering.The small number of lovingly-handcrafted data types means often the only choice you need make is between Fast or Compact.This version is pure python, no dependencies apart from Six (and pytest for the tests).
Tested working in python 3.8 & 2.7 on windows & linux.VersionB3 is now version 1.x, it is out of beta.The wire format and existing core data types are nowfrozenandwill not change.Except for the unused core types 10,11,12 which may have a type assigned in future, andExcept for SCHEDs unfinished named-timezone support, which needs py3.10+)(v1.x is not backward compatible with beta 0.9.x versions)Installingpip install b3buf

>>> import b3Getting StartedYou can pack lists of things (like json.dumps):import b3
list_data = [ None,  b"foo",  u"bar",  True,  -69,  2.318,  46j,  [1,2,3],  {4:5, 6:7},
              decimal.Decimal("13.37"), datetime.datetime.now() ]

list_buf = b3.pack(list_data)

out_list = b3.unpack(list_buf)Complex numbers, decimal numbers, and dates and times all work.You can pack dicts of things:dict_data = { 1:1, u"2":u"2", b"3":b"3" }

dict_buf = b3.pack(dict_data)

out_dict = b3.unpack(dict_buf, 0)Byte keys are supported as well as string and number keysYou can save on slicing when unpacking by giving unpack a start indexSchema PackingYou can make messages using a "type, name, tag_number" schema (like protobuf)SCHEMA = (
    (b3.B3_BYTES,   "bytes1",  1),
    (b3.B3_UVARINT, "number1", 2),
    )Schema packing/unpacking is to and from python Dicts.sch_data = dict(bytes1=b"foo", number1=69)

sch_buf = b3.schema_pack(SCHEMA, sch_data)

out_sch = b3.schema_unpack(SCHEMA, sch_buf)TestsB3 ships with an extensive test suite, using pytest.pip install pytest
cd /your/site-packages/b3
pytestMore InfoSee the tests, and examples.py in the tests folder for more examples (including how to nest schemas)See datatypes.py for the available data types.See wire_format.md for an overview of the wire format.LicensingThe code in this project is licensed under MIT license. See LICENSE.txt.
Package: b3-cdi-curve
B3 CDI Curve by FluxonautThis package is a collection of Python scripts that extracts, consolidates and interpolates data from the Brazilian CDI Curve provided on the B3 Exchange web site.
It allows you to produce a historical data series for any given duration (considering it respects the maximum available duration). It stores all the term structure of the CDI curve in a local SQLite database as well.Setup and usageJust install from PyPI as shown below.pipinstallb3-cdi-curveNow just import it to your project. The package exposes two methods,sync_db()andcreate_time_series(duration: int).
Below you can find a basic usage example and a more detailed explanation.importb3cdi# Create and/or update local DBb3cdi.sync_db()# Create time series for the desired duration (in days)b3cdi.create_time_series(360)sync_dbThis method loops through all the dates between the beginning of the series and the last working day looking for the prices on the B3 web site. It then generates and saves a local SQLite database (located on ./output/cdi.db).The first run takes around two and half hours to build the database and it takes around 1.35 GB of disk space.After it runs once, it'll check for the last inserted date, so it'll look only for working days after the last update. This keeps the database updated for each time you run the code.create_time_seriescreate_time_series(duration:int)This method queries the local database to produce a Pandas DataFrame with the historical series of the requested duration. It then saves it as a CSV file on the ./output/ folder.The parameter of the method is where you input your desired duration (e.g. 360).ContributingPull requests are welcome. Please open an issue first to discuss what you would like to change.To-doTestsOptimize db sizeFluxonautThis code was made possible by the amazing people working at Fluxonaut who dedicated their free time to help the community. Please be sure to check our our website athttps://fluxonaut.com.LicenseThis project is under theMITlicense.
Package: b3d
b3dBoto3 utility library that supports deletion of collections of AWS resources (such as temporary resources created during unit tests).UsageThe functionb3d.delete_resourcesis used to remove all AWS resources with a particular key / value tag
pair. It can be called as follows:fromb3dimportdelete_resourcesreports=delete_resources("tag_key","tag_value","aws_region_name",dry=False)Thedelete_resources()function returns an iterator whose elements are lists of reports for each single resource.
A list of reports is yielded (rather than an individual report) because a delete procedure might involve detaching
any number of resources from the target resource first. Each report will detail the type of action performed (e.g.
detachment from another resource, deletion, noop), whether that action was successful, and an error message if
appropriate.Ifdry=True,delete_resourceswill perform all the same queries on AWS resources, but all detach and delete
operations will be skipped. The same reports list will therefore be produced, but the resources themselves will be
unaffected.
Package: b3futurecontracts
b3futurecontractsB3 is a stock exchange in Sao Paulo, Brazil. This module evaluates the rollover date of some of its future contracts.ClassesCurrently this module provides two classes,B3FutureIndexandB3FutureDollar. These classes have two main methods,rollover_dateandcurrent_name; both take a date as argument and return the rollover date and the current names of the future contract as of the given date, respectively.Sample code>>>importdatetimeasdt>>>fromb3futurecontractsimport*>>>>>>today=dt.date.today()>>>print(today)2019-12-01>>>>>>futureindex=B3FutureIndex(today)>>>print(futureindex.rollover_date(),futureindex.current_name()[0])2019-12-11WINZ19>>>$python-mb3futurecontracts2019-01-052019-02-13WING192019-02-01WDOG192019-01-202019-02-13WING192019-02-01WDOG192019-02-052019-02-13WING192019-03-01WDOH192019-02-202019-04-17WINJ192019-03-01WDOH192019-03-052019-04-17WINJ192019-04-01WDOJ192019-03-202019-04-17WINJ192019-04-01WDOJ192019-04-052019-04-17WINJ192019-05-02WDOK192019-04-202019-06-12WINM192019-05-02WDOK192019-05-052019-06-12WINM192019-06-03WDOM192019-05-202019-06-12WINM192019-06-03WDOM192019-06-052019-06-12WINM192019-07-01WDON192019-06-202019-08-14WINQ192019-07-01WDON192019-07-052019-08-14WINQ192019-08-01WDOQ192019-07-202019-08-14WINQ192019-08-01WDOQ192019-08-052019-08-14WINQ192019-09-02WDOU192019-08-202019-10-16WINV192019-09-02WDOU192019-09-052019-10-16WINV192019-10-01WDOV192019-09-202019-10-16WINV192019-10-01WDOV192019-10-052019-10-16WINV192019-11-01WDOX192019-10-202019-12-18WINZ192019-11-01WDOX192019-11-052019-12-18WINZ192019-12-02WDOZ192019-11-202019-12-18WINZ192019-12-02WDOZ192019-12-052019-12-18WINZ192020-01-02WDOF202019-12-202020-02-12WING202020-01-02WDOF20
$Installationpipinstallb3futurecontracts
Package: b3get
library to download image sets from Broad Bioimage Benchmark Collection imagesFree software: BSD 3-Clause LicenseInstallationpip install b3getDocumentationhttps://b3get.readthedocs.io/DevelopmentTo run the all tests run:toxNote, to combine the coverage data from all the tox environments run:Windowsset PYTEST_ADDOPTS=--cov-append
toxOtherPYTEST_ADDOPTS=--cov-append toxChangelog0.0.0 (2019-02-15)First release on PyPI.
Package: b3j0f.annotation
DescriptionAnnotation library like Java’s annotation with reflective concerns for Python.LinksHomepagePyPIDocumentationInstallationpip install b3j0f.annotationFeaturesWhat does mean annotations in a reflective way:one annotation can annotate several objects at a time (modules, classes, functions, instances, builtins, annotation like themselves, etc.).such as a reflective object, they could have their own behavior and lifecycle independently to annotated elements.This library provides the base Annotation class in order to specialize your own annotations, and several examples of useful annotation given in different modules such as:async: dedicated to asynchronous programming.interception: annotations able to intercept callable object calls.call: inherits from interception module and provides annotations which allow to do checking on callable objects.check: annotations which check some conditions such as type of annotated targets, max number of annotated elements, etc.oop: useful in object oriented programming like allowing to weave mixins.ExamplesPerspectivesCython implementation.Donation
Package: b3j0f.sync
DescriptionThis system is dedicated to help to synchronize data of resources.LinksHomepagePyPIDocumentationInstallationpip install b3j0f.syncFeaturesThe global architecture is composed of four classes:Synchronizer: class which is linked to several stores in order to propagate data CRUD operations on these last ones.Store: class which represents a set of data, and uses one Accessor per data type in order to access to self data.Accessor: class which permits to access and create data.Data: specific to an accessor, it is the abstraction class used to exchange data information among stores.Therefore, one Store can be used by several synchronizers, and one Accessor can be used by several Stores.The Synchronizer and the Store are configurables (seeb3j0f.conf). Configuration files are installed in the~/etc/directory.If you want to specialize this system to your own needs, you have to extend abstract classes with implementation of 6 CRUD methods for the Accessor.The system does not use semantical mechanisms, therefore, the system is in abest effortmode instead to be exhaustive.Examplesb3j0f.dmts: development management tool synchronizer.LimitationsName limitationIn order to ensure data consistency among several stores, the system choose to find any data from its name and context name (aka, name of embedding data).Therefore, this system is not able to synchronize data which are of the same type of other data, in the same context, and with the same name.Perspectivesbreak thename limitationwith a store dedicated to ensure correspondance between store data ids.use a data id of type int instead of type str, for memory reasons.wait feedbacks during 6 months before passing it to a stable version.Cython implementation.Donation
Package: b3j0f.task
DescriptionPython object configuration library in reflective and distributed concerns.LinksHomepagePyPIDocumentationInstallationpip install b3j0f.taskFeaturesThis library performs execution of registered python routines.Examplesfromb3j0f.taskimportregister,run@register@register('mytask')deftask(a,*args,**kwargs):returnaregister(task,name='lastname')assertrun({'name':'task','kwargs':{a=1}})==1assertrun({'name':'mytask','args':[2]})==2assertrun({'name':'lastname','kwargs: {'a': 3}}) == 3Perspectiveswait feedbacks during 6 months before passing it to a stable version.Cython implementation.Donation
Package: b3parser
B3ParserUm parser para os arquivos de histórico de cotações da B3Exemplo de utilização (main.py)fromb3parserimportB3Parserif__name__=='__main__':cols_sel=['data_pregao','cod_bdi','cod_papel','tp_merc','nome_resum','espec_papel','preco_ultimo','fator_cotacao',]cods_bdi=['02',# LOTE PADRÃO'12',# FUNDOS IMOBILIÁRIOS'96',# FRACIONÁRIO]tps_merc=['010',# VISTA'020',# FRACIONÁRIO]filtros={'cod_bdi':('in',cods_bdi),'tp_merc':('in',tps_merc),}ano=2015parser=B3Parser('data/COTAHIST_A{0}.TXT'.format(ano))parser.ler_arquivo(cols_sel=cols_sel,filtros=filtros)parser.exportar_json('data/{0}.json'.format(ano))#parser.exportar_sql( 'data/{0}.sql'.format( ano ) )#parser.exportar_csv( 'data/{0}.csv'.format( ano ) )Links úteisDependênciaspymongo- Driver MongoDbtqdm- Barra de progressoCotações históricasCotações Históricas- Busca por cotações históricasLayoutdas cotações históricasArquivos de cotações históricasAnuais: FormatoCOTAHIST_AAAAA.ZIPMensais(últimos 12 meses): FormatoCOTAHIST_MMMAAAA.ZIPDiárias(ano corrente): FormatoCOTAHIST_DDDMMAAAA.ZIPTítulos negociáveisTítulos Negociáveis: Busca por títulos negociáveisTítulos Negociados: Títulos negociados atualmenteGlossáriodos títulos negociáveisProjetos similares no GitHubBusca 1Busca 2
Package: b3tojson
b3tojsonThis utility is intended to help converting B3 (Brasil, Bolsa, Balcão) own data format to a more portable and usable format like JSON.Dependenciesjsonpickle==1.3requests==2.23.0For testing onlypytest==5.4.1pytest-mock==3.0.0InstallingFrom sourcepip install -r requirements.txtpip install .From PyPIpip install b3tojsonRunningThere are some configurable parameters when running in the command line. It is even possible to automatically get the latest source file and parse into a new JSON. Options are:--fetchEnables downloading of a new data file from B3 server. It will consider this file when parsing. This is disabled by default, try to parse a local file under files folder.--b3_file FILENAMESpecifies the local data file location. Make sure that it is UTF-8 encoded, other encoding may not work.--json_file JSONNAMESpecifies the name of the resulting JSON file. Defaults to files/stocks_data.json.Important to note that--fetchand--b3_fileare mutually exclusive.ExampleRunning to fetch a new file and customize the resulting JSONb3tojson --fetch --json_file files/beautiful_file.jsonUsing a local file to parseb3tojson --b3_file files/my_local_file.txt
Package: b4rpipe
b4rpipePipeline reduction tools for B4R/LMT data.Installation$ pip install b4rpipeUsageReduce individual data$ python
$ >>> import b4rpipe as Bp
$ >>> Bp.globBaseDir = '/home/hoge/b4r'
$ >>> Bp.globLogDir = '/home/hoge/b4r/logv1'
$ >>> Bp.PipelineAnalysis(86420)This example shows a pipeline analysis for the data obsid 86420.Reduce all data (for database)$ python
$ >>> import b4rpipe as Bp
$ >>> Bp.globBaseDir = '/home/hoge/b4r'
$ >>> Bp.globLogDir = '/home/hoge/b4r/logv1'
$ >>> Bp.PipelineAnalysisBatchRun()You need to specify following pathes.b4pipe.globBaseDirThe path where "xffts" and "lmttpm" directorys are located.XFFTS binary data (e.g., xffts20181003111006.xfftsx.01) should be stored under the "xffts" directory.LMT antenna log data (e.g., lmttpm_2018-04-22_075858_01_0000.nc) should be stored under the "lmttpm" directory.b4rpipe.globLogDirThe path where outputs are created.Anywhere you like is OK.ProductsThe script create following outputs (if possible).Continuum Map Qlook (Pointing offset, efficiency (only for uranus), etc.)Line (SiO) Map Qlook (Pointing offset, etc.)Spectrum Qlook (with auto-flag)Time series spectrum of PSW data (numpy readable format)GoDec calibration results (see Taniguch et al. 2021)MS2 (CASA readable format)Data query and download (only for internal use now)If you are in the NAOJ or IoA (U. Tokyo) local network, you can access the B4R ftp server.$ python
$ >>> import b4rpipe as Bp
$ >>> Bp.PipelineAnalysis(86420,DataDownload=True,username='hogehoge',password='*****')Then "rawdata" and "calibrated" directory appears at the current directory.$ ls
raw calibrated
$ ls rawdata
lmttpm xffts
$ls calibrated
86420CorrespondenceB4R 2018/2019 (obsnum<=087433) data <-> CASA MS2NameB4RCASA MS2polarizationA(correlation or stokes) YYpolarizationB(correlation or stokes) XXsidebandLSBspw 0sidebandUSBspw 1InformationB4R webpage:http://lmtgtm.org/b4r/?lang=enContact: Yuki Yoshimura
(email: astro.yoshimura(at)gmail.com)