Saravanan666/pypi-org huggingface dataset:
Package: boba
bobaAuthor and visualize multiverse analysis with ease.Boba has a domain specific language (Boba DSL) for writing multiverse specifications,
and a visual analysis interface (Boba Visualizer) for exploring multiverse outcomes.
Boba comes with a command line tool to parse your DSL specification and generate
universe scripts, execute all scripts with a single command,
merges outputs into a table, and invoke the visualizer.works with both python and R, and other scripting languages to comehandles simple parameter substitution as well as complex code flow dependencyoffers interactive visualizations for exploring consequential decisions, uncertainty, model fit, and moreInstallationYou might download and install the latest version of this software from the
Python package index (PyPI):pip install --upgrade boba
pip install --upgrade boba-visualizerUsageTo author your multiverse, please refer to the specificationrules.
Here is asimple exampleto get you started!To parse your specification and generate actual scripts, invoke boba and pass
in the path to your template script and your JSON spec:boba compile --script template.pyTo execute the multiverse, namely running all the generated scripts, use:boba run --allTo start the Boba Visualizer after getting the intermediate output files, use:boba-serverFor more command line options, seeCLI.
For more information about the Boba Visualizer, see thisproject.ExamplesAsimple exampleto walk you through the basicsAmore complex exampleusingSteegen’s multiverse analysisandDurante’s fertility dataset.Another multiverseexample, based on thespecification curve paperby Simonsohn et al.CitationIf you are interested in this work, please see our researchpaperand consider citing our work:@misc{liu2020boba,
  title={Boba: Authoring and visualizing multiverse analyses},
  author={Yang Liu and Alex Kale and Tim Althoff and Jeffrey Heer},
  year={2020},
  eprint={2007.05551},
  archivePrefix={arXiv},
  primaryClass={cs.HC}
}History1.1.2 (2021-04-25)Remove the dependency on boba-visualizer1.1.1 (2021-04-25)Support the Boba monitor1.1.0 (2020-10-07)Add support for arbitrary languageVarious bug fixes1.0.0 (2020-07-31)Support continuous placeholder variableSupport running the multiverse across multiple processesImprove boba run, such that it is not dependent on the OSVarious bug fixesIntegrate boba visualizer0.1.4 (2020-04-19)Combine JSON spec with the templateSupport inline definition for placeholder variablesSupport inline constraint at block declarationSupport linked decisionsInfer ADG from specificationUpdate examplesVarious bug fixes0.1.3 (2019-11-30)Revise authoring syntax to support decision blocks and constraintsRevise CLI, with separate commands to compile and to runImprove executionAdd the hurricane example0.1.2 (2019-09-19)Fix bugs0.1.1 (2019-09-19)Support RImprove CLI optionsSupport a built-in variable {{_n}}, which represents the universe numberSupport “before_execute” and “after_execute” hooks in the JSON specUpdate examples0.1.0 (2019-08-26)First release on PyPI.
Package: boba-fetch
BobaA tool for polling a remote source over SSH and syncing new files from said source usingrsync.Setup & UsageInstallationboba-fetchcan be easily installed withpip:pip3installboba-fetchUsageThe most up-to-date instructions for use can be found usingboba-fetch --help, however, the basic idea is that you need to have a server configured with ssh public key authentication. You should be able to access the server usingssh <servername>. Once that's set up, usingboba-fetchis pretty easy:boba-fetch-r<SERVERNAME>-s/path/to/remote/watched/directory-d/path/to/local/download/directory-g/path/to/local/staging/directory-t/path/to/local/tracking/directoryThe staging directory should be on the same drive as the download directory to speed up transfers and have the files "just appear" in the right place. The tracking directory should be unique for every configuration ofboba-fetchthat you run because its used to keep track of which files have been downloaded and when, which allowsboba-fetchto redownload the files if it discovers that they have beenDevelopmentStandardsBe excellent to each otherCode coverage must be at 100% for all new code, or a good reason must be provided for why a given bit of code is not covered.Example of an acceptable reason: "There is a bug in the code coverage tool and it says its missing this, but its not".Example of unacceptable reason: "This is just exception handling, its too annoying to cover it".The code must pass the following analytics tools. Similar exceptions are allowable as in rule 2.pylint --disable=C0103,C0111,W1203,R0903,R0913 --max-line-length=120 testudoflake8 --max-line-length=120 ...mypy --ignore-missing-imports --follow-imports=skip --strict-optional ...All incoming information from users, clients, and configurations should be validated.All internal arguments passing should be typechecked during testing withtypeguard.typecheckedorthe import hook.Development SetupUsingpdminstall from inside the repo directory:pdminstallThis will set up a virtualenv which you can always run specific commands withpdm run ....DevelopmentTestingAll testing should be done withpytestwhich is installed with the--devrequirements (pdm --dev install ...).To run all the unit tests, execute the following from the repo directory:pdmrunpytestThis should produce a coverage report in/path/to/dewey-api/htmlcov/While developing, you can usewatchexecto monitor the file system for changes and re-run the tests:watchexec-r-epy,yamlpdmrunpytestTo run a specific test file:pdmrunpytesttests/unit/test_cli.pyTo run a specific test:pdmrunpytesttests/unit/test_cli.py::test_cli_basicsFor more information on testing, see thepytest.inifile as well as thedocumentation.Build/Publishpdmbuild;pdmpublish-test;pdmpublish-prod;
Package: bobail
A Python3 library that you can use to play a game of bobail. This is just a set of classes that you can use in your code, it's not an interactive shell for the game.AssumptionsThe rules used are from BoardGameAreana (http://en.doc.boardgamearena.com/Gamehelpbobail). This means an 5x5 board.Each position on the board is numbered 1 to 25. Each move is represented as an array with two values: starting position and ending position. So if you're starting a new game, one of the available moves is[22, 7]for player 1.Each turn (other than the first) will be a series of two moves.  First moving the Bobail then a player token.UsageCreate a new game:frombobail.gameimportGamegame=Game()See whose turn it is:game.whose_turn()#1 or 2Get the possible moves:game.get_possible_moves()#[[9, 13], [9, 14], [10, 14], [10, 15], [11, 15], [11, 16], [12, 16]]Make a move:game.move([9,13])Check if the game is over:game.is_over()#True or FalseFind out who won:game.get_winner()#None or 1 or 2Review the move history:game.moves#[[int, int], [int, int], ...]Review the pieces on the board:forpieceingame.board.pieces:piece.player#1 or 2piece.other_player#1 or 2piece.bobail#True or Falsepiece.captured#True or Falsepiece.position#1-25piece.get_possible_moves()#[[int, int], [int, int], ...]TestingRunpython3 -m unittest discoverfrom the root.
Package: bob-ajax-selects
Enables editing ofForeignKey,ManyToManyFieldandCharFieldusing jQuery UI AutoComplete.The user types a search term into the text fieldAn ajax request is sent to the server.The dropdown menu is populated with results.User selects by clicking or using arrow keysSelected result displays in the “deck” area directly below the input field.User can click trashcan icon to remove a selected itemDjango 1.2+Optional boostrap mode allows easy installation by automatic inclusion of jQueryUI from the googleapis CDNCompatible with staticfiles, appmedia, django-compressor etcPopup to add a new item is supportedAdmin inlines now supportedAjax Selects works in the admin and also in public facing forms.Rich formatting can be easily defined for the dropdown display and the selected “deck” display.Templates and CSS are fully customizableJQuery triggers enable you to add javascript to respond when items are added or removed, so other interface elements on the page can reactDefault (but customizable) security prevents griefers from pilfering your data via JSON requests
Package: bobalkkagi
TEAM BobalkkagiBOB11 projectUnpacking & Unwrapping & Devirtualization(Not yet) of Themida 3.1.3 packed program(Tiger red64)API HookHooking API based win10_v1903How toInstallpip install bobalkkagiorpip install git+https://github.com/hackerhoon/bobalkkagi.gitNotesNeed default Dll folder(win10_v1903) or you can give dll folder pathwin10_v1903 folder is inhttps://github.com/hackerhoon/bobalkkagiUseNAME
    bobalkkagi

SYNOPSIS
    bobalkkagi PROTECTEDFILE <flags>

POSITIONAL ARGUMENTS
    PROTECTEDFILE
        Type: str

FLAGS
    --mode=MODE
        Type: str
        Default: 'f'
    --verbose=VERBOSE
        Type: str
        Default: 'f'
    --dllPath=DLLPATH
        Type: str
        Default: 'win10_v1903'
    --oep=OEP
        Type: str
        Default: 't'
    --debugger=DEBUGGER
        Type: str
        Default: 'f'

NOTES
    You can also use flags syntax for POSITIONAL ARGUMENTSOption DescriptionMode: f[fast], c[hook_code], b[hook_block]Description: Mean emulating mode, we implement necessary api to unpack protected excutables by themida 3.1.3.Running onfast modecompare rip with only hook API function area size 32(0x20), buthook_block modeandhook_code modecompare rip with all mapped DLL memory (min 0x1000000) to check functions. block mode emulate block size(call, jmp) code mode do it opcode by opcode.verboseverboseshow Loaded DLL on memory, we will update it to turn on/off HOOKING API CALL info.dllPathdllPathis directory where DLLs to load on memory exists. DLLs are different for each window version.
This tool may be not working with your window DLL path(C:\Windows\System32)oepoepis option to find original entry point. If you turn off this option, you can emulate program after oep**(fast mode can't do it, it works on hook_block and hook_code)**debuggerIf you want unpack another protector or different version of themida, you should add necessary hook_api functions(anti debugging, handle, syscall). you can analyze protected program hook_code mode or hook_block mode(more detail inhttps://github.com/unicorn-engine/unicorn) withdebugger ** option(working only hook_code mode!)**
Package: bob.ap
Audio Processing for BobThis package is part of the signal-processing and machine learning toolboxBob. It contains basic audio processing utilities. Currently, the following cepstral-based features are available:
using rectangular (RFCC), mel-scaled triangular (MFCC)[Davis1980], inverted mel-scaled triangular (IMFCC),
and linear triangular (LFCC) filters[Furui1981], spectral flux-based features (SSFC)[Scheirer1997],
subband centroid frequency (SCFC)[Le2011]. We are planning to update and add more features in the
near future.Please note that the implementation of MFCC and LFCC features has changed compared to an earlier version of the package,
as we corrected pre-emphasis and DCT computations. Delta and delta-delta computations were slightly changed too.InstallationComplete Bob’sinstallationinstructions. Then, to install this package,
run:$ conda install bob.apContactFor questions or reporting issues to this software package, contact our
developmentmailing list.[Davis1980]S. Davis and P. Mermelstein, “Comparison of parametric representations for monosyllabic
word recognition in continuously spoken sentences”, in IEEE Transactions on Acoustics, Speech, and Signal Processing,
1980, num 4, vol. 28, pages 357-366.[Furui1981]S. Furui, Cepstral analysis technique for automatic speaker verification, in
IEEE Transactions on Acoustics, Speech, and Signal Processing, 1981, num 2 vol 29, pages 254-272.[Scheirer1997]E. Scheirer and M. Slaney, Construction and evaluation of a robust multifeature speech/music discriminator,
in IEEE International Conference on Acoustics, Speech, and Signal Processing, ICASSP, 1997, vol 2, pages 1331-1334.[Le2011]P. N. Le, E. Ambikairajah, J. Epps, V. Sethu, E. H. C. Choi, Investigation of Spectral Centroid Features for Cognitive Load Classification,
in Speech Commun., April, 2011, num 4, vol 53, pages 540–551.
Package: boba-visualizer
boba-visualizerThe Boba Visualizer is a visual analysis interface for exploring multiverse outcomes.
It helps users explore how analytic decisions impact statistical estimates, inferential uncertainty, and model fit.
Watch the visualizer in action in thisvideo.InstallationYou might download and install the latest version of this software from the
Python package index (PyPI):pip install --upgrade boba-visualizerUsageTo start the visualizer, use the following command:boba-server -i /path/to/fileYou will need to supply your own file path, which contains your multiverse outcomes and
accompanying meta data. Learn more about the appropriate file formathere. This repository
also include anexample folderwith the outcomes from themortgage multiverse. You
could explore the example by cloning this repo and:boba-server -i ./example/mortgageAfter running the above command in your console, open your browser and navigate tohttp://127.0.0.1:8080/to start the user interface.You might also use aconfiguration fileto control various aspects of the visualizer,
and useCLI optionsto change the behavior of the server.History1.1.1 (2021-04-25)Fix bug.1.1.0 (2021-04-25)Introduce the Boba monitor.Improve the sensitivity test.Add a gallery of static charts, in /#/charts1.0.3 (2020-10-26)Allow changing server host and port.1.0.2 (2020-10-07)Fix various bugs.Allow switching sensitivity method in the config.1.0.1 (2020-09-31)Fix bug.1.0.0 (2020-07-31)First release on PyPI.
Package: bobbie
bobbie provides a lightweight, easy-to-use, flexible class for loading and storing configuration settings for a python project. Unlike some other packages, bobbie neither tinkers with environment variables nor limits users to a single source type. boobbie has built-in type inference for data sources (e.g. ini files) which do not allow for typing. bobbie stores the configuration settings in a class which can be used both as a drop-in dict and with extra features for accessing specific settings.bobbie's framework supports a wide range of coding styles. You can create complex multiple inheritance structures with mixins galore or simpler, compositional objects. Even though the data structures are necessarily object-oriented, all of the tools to modify them are also available as functions, for those who prefer a more funcitonal approaching to programming.The project is also highly internally documented so that users and developers can easily make bobbie work with their projects. It is designed for Python coders at all levels. Beginners should be able to follow the readable code and internal documentation to understand how it works. More advanced users should find complex and tricky problems addressed through efficient code.
Package: bobbin
BobbinWhat is this?A small tool for making neural net training loop with flax.linen.This library is designed to be a set of small tools and not to be a full-blown
framework for deep learning.  Users should keep freedom not to use some parts
of this library and the rest of the library should still be able to serve the
users.Currently, this library contains the following components:cron:
Tools for defining and performing periodical actions in the training-loop.evaluation:
Helpers for performing evaluation and handling metrics.pmap_utils:
Tools for helping the use ofjax.pmap.pytypes:
Type definitions for better type annotations.tensorboard:
Helper functions for publishing training state and evaluation summaries.training:
Helpers for writing training-loops for Flax models.var_utils:
Utility for accessing variable collections of Flax models.ContributingSeeCONTRIBUTING.mdfor details.LicenseApache 2.0; seeLICENSEfor details.DisclaimerThis library is still in a very early phase of development, and therefore,
its API can often be subject to destructive change.This project is not an official Google project. It is not supported by
Google and Google specifically disclaims all warranties as to its quality,
merchantability, or fitness for a particular purpose.
Package: bob.bio.base
Tools to run biometric recognition experimentsThis package is part of the signal-processing and machine learning toolboxBob. It provides tools to run comparable
and reproducible biometric recognition experiments on publicly available
databases.TheUser Guideprovides installation and usage instructions.
If you run biometric recognition experiments using the bob.bio framework,
please cite at least one of the following in your scientific publication:@inbook{guenther2016face,
  chapter = {Face Recognition in Challenging Environments: An Experimental and Reproducible Research Survey},
  author = {G\"unther, Manuel and El Shafey, Laurent and Marcel, S\'ebastien},
  editor = {Bourlai, Thirimachos},
  title = {Face Recognition Across the Imaging Spectrum},
  edition = {1},
  year = {2016},
  month = feb,
  publisher = {Springer}
}

@inproceedings{guenther2012facereclib,
  title = {An Open Source Framework for Standardized Comparisons of Face Recognition Algorithms},
  author = {G\"unther, Manuel and Wallace, Roy and Marcel, S\'ebastien},
  editor = {Fusiello, Andrea and Murino, Vittorio and Cucchiara, Rita},
  booktitle = {European Conference on Computer Vision (ECCV) Workshops and Demonstrations},
  series = {Lecture Notes in Computer Science},
  volume = {7585},
  year = {2012},
  month = oct,
  pages = {547-556},
  publisher = {Springer},
}InstallationComplete Bob'sinstallation instructions. Then, to
install this package, run:condainstallbob.bio.baseContactFor questions or reporting issues to this software package, contact our
developmentmailing list.
Package: bob.bio.caffe-face
Face Feature extraction using caffe pre-trained modelsThis package is part of the signal-processing and machine learning toolboxBob. This package is part of thebob.biopackages, which allow to run
comparable and reproducible biometric recognition experiments on publicly
available databases.This package contains functionality to run face recognition experiments. It is
an extension to thebob.bio.basepackage, which provides the basic scripts. With this package it is possible to
run feature extraction using pre-trained models ofCaffe.InstallationComplete Bob’sinstallationinstructions. Then, to install this package,
run:$ conda install bob.bio.caffe_faceContactFor questions or reporting issues to this software package, contact our
developmentmailing list.
Package: bob.bio.csu
bob.bio Wrapper classes for the CSU Face Recognition ResourcesThis package is part of thebob.biopackages, which allow to run comparable and reproducible biometric recognition experiments on publicly available databases.This package provides wrapper classes for the CSU face recognition resources, which can be downloaded fromhttp://www.cs.colostate.edu/facerec.
Two algorithms are provided by the CSU toolkit (and also by this package): the local region PCA (LRPCA) and the LDA-IR (also known as CohortLDA).For more information about the LRPCA and the LDA-IR algorithm, please refer to the documentation onhttp://www.cs.colostate.edu/facerec.
For further information aboutbob.bio, please readits Documentation.Installation InstructionsThe current package is just a set of wrapper classes for the CSU facerec2010 module, which is contained in theCSU Face Recognition Resources, where you need to download the Baseline 2011 Algorithms.
Please make sure that you have read installation instructions in theDocumentationof this package on how to patch the original source code to work with our algorithms, before you try to go on woth this package.NoteSince the original CSU resources are not Python3 compatible, this package only supports Python2.
For external dependencies of the CSU resources, please read theirREADME.Thebob.biopackages and parts of this package rely onBob, an open-source signal-processing and machine learning toolbox.
ForBobto be able to work properly, some dependent packages are required to be installed.
Please make sure that you have read theDependenciesfor your operating system.DocumentationFor further documentation on this package, please read theStable Versionor theLatest Versionof the documentation.For a list of tutorials on packages obBob, or information on submitting issues, asking questions and starting discussions, please visit its website.
Package: bob.bio.face
Run face recognition algorithmsThis package is part of the signal-processing and machine learning toolboxBob.
This package is part of thebob.biopackages, which allow to run
comparable and reproducible biometric recognition experiments on publicly
available datasets.This package contains functionality to run face recognition experiments.
It is an extension to thebob.bio.basepackage, which
provides the basic scripts.
In this package, utilities that are specific for face recognition are
contained, such as:Image databasesImage preprocesors, including face detection and facial image alignmentImage feature extractorsRecognition algorithms based on image featuresInstallationComplete Bob'sinstallation instructions. Then,
to install this package, run:condainstallbob.bio.faceContactFor questions or reporting issues to this software package, contact our
developmentmailing list.
Package: bob.bio.face-ongoing
Face recognition ongoingThe goal of this package is to provide an “easy to reproduce” set of experiments in some large scale
face recognition databases.This package is part of the signal-processing and machine learning toolboxBob.
This package is part of thebob.biopackages, which allow to run comparable and reproducible biometric recognition experiments on publicly available databases.This package containsbob.bio.baseconfiguration of same face recognition baselines.
It’s also contains some discussions about the baselines and databasese.InstallationFollow ourinstallationinstructions. Then, using the Python interpreter
provided by the distribution, bootstrap and buildout this package:$ conda install bob.bio.face_ongoingContactFor questions or reporting issues to this software package, contact our
developmentmailing list.
Package: bob.bio.gmm
Run Gaussian mixture model based algorithmsThis package is part of the signal-processing and machine learning toolboxBob.
This package is part of thebob.biopackages, which allow to run comparable and reproducible biometric recognition experiments on publicly available databases.This package contains functionality to run biometric recognition algorithms based on Gaussian mixture models (GMMs).
It is an extension to thebob.bio.basepackage, which provides the basic scripts.
In this package, utilities that are specific for using GMM-based algorithms are defined:Recognition algorithms based on Gaussian mixture modelsScripts to run the training of these algorithms in parallelInstallationComplete Bob’sinstallationinstructions. Then, to install this package,
run:$ conda install bob.bio.gmmContactFor questions or reporting issues to this software package, contact our
developmentmailing list.
Package: bob.bio.htface
Run heterogeneous face recognition algorithmsThis package is part of the signal-processing and machine learning toolboxBob.
This package is part of thebob.biopackages, which allow to run comparable and reproducible biometric recognition experiments on publicly available databases.InstallationFollow ourinstallationinstructions. Then, using the Python interpreter
provided by the distribution, bootstrap and buildout this package:$ conda install bob.bio.htface
$ bob bio htface --helpContactFor questions or reporting issues to this software package, contact our
developmentmailing list.