Saravanan666/pypi-org huggingface dataset:
Package: burp-ui
ContentsIntroductionDemoWhat’s that?Who are you?DocumentationFAQCommunityNotesSee alsoLicensesThanksIntroductionDemoA screenshot is worth a thousand words, but a Demo is worth a thousand
screenshots.
You can now play withBurp-UIatdemo.burp-ui.orgCredentials:admin/adminto play withBurp-UIas an administratormoderator/moderatorto play withBurp-UIas a moderatordemo/demoto play withBurp-UIas a regular userWhat’s that?Let me introduce youBurp-UI. It is a web-based UI to manage your
burp-servers.
You can view different reports about burp-servers, burp-clients, backups, etc.Burp-UIallows you to performonlinerestorations and to edit/manage
your burp-server’s configuration files.Who are you?I’mZiirish, a FrenchDevOpswho lovesBurpand
who’d like to help its adoption by providing it a nice and powerful interface.
If you like my work, you can:Thank me by sending me an email or writing nice commentsBuy me a beer or some fries (or both!)Make a donation on myPaypalDocumentationThe documentation is hosted onreadthedocsat the
following address:burp-ui.readthedocs.ioFAQAFAQis available with the documentation.CommunityPlease refer to theContributingpage.NotesFeel free to report any issues on mygitlab.I have closed thegithub trackerto have a unique tracker system.Also please, read theContributingpage before reporting any issue to make
sure we have all the informations to help you.
Bug report that don’t comply with the rules will likely beignoredbecause
my spare time is quite limited.See alsoStarting with burp-ui v0.3.0, I introduced youburp_server_reporta project lead by Pablo Estigarribia.Pablo also contributed to other interesting projects to automate burp and burp-ui
deployments through Ansible:burpui_serverburp2_server@qm2k contributed some scripts/config to tweak your setup. You can found them here:burp-ui_integrationburp_integrationLicensesBurp-UIis released under the BSD 3-clauseLicense.But this project is built on top of other tools. Here is a non exhaustive list:d3.jsnvd3.jsjQueryjQuery-UIfancytreebootstraptypeaheadbootswatchthemeSlateangular-bootstrap-switchangular.jsangular-ui-selectAngularStraplodashDataTablesHome-madefaviconbased on pictures fromsimpsoncrazyAlso note that this project is made with the AwesomeFlaskmicro-framework.ThanksThank you all for your feedbacks and bug reports. Those are making the project
moving forward.Thank you to theFlaskdevelopers and community.Special Thanks to Graham Keeling for his great piece of software! This project
would not exist withoutBurp.
Package: burr
BurrWhat is Burr?Burr is a state machine for data/AI projects. You can (and should!) use it for anything where managing state can be hard. Hint: managing state
is always hard!Link todocumentation.Burr is:A (dependency-free) python library that enables you to build and manage state machines with simple python functionsA server that can run your state machines and provide a UI to track execution/debugWhat can you do with Burr?Burr can be used for a variety of applications. Burr can build a state machine to orchestrate, express, and track:A gpt-like chatbotA machine learning pipelineA trading simulationAnd a lot more!Using hooks and other integrations you can (a) integrate with any of your favorite vendors (LLM observability, storage, etc...), and
(b) build custom actions that delegate to your favorite libraries.Burr willnottell you how to build your models, how to query APIs, or how to manage your data. It will help you tie all these together
in a way that scales with your needs and makes following the logic of your system easy. Burr comes out of the box with a host of integrations
including tooling to build a UI in streamlit and watch your state machine execute.Why the name Burr?Burr is named after Aaron Burr, founding father, third VP of the United States, and murderer/arch-nemesis of Alexander Hamilton.
We imagine a world in which Burr and Hamilton lived in harmony and saw through their differences. We originally
built Burr as aharnessto handle state between executions of Hamilton DAGs,
but realized that it has a wide array of applications and decided to release it.Getting StartedTo get started, install frompypi, using your favorite package manager:pipinstall"burr[start]"This includes the dependencies for the tracking server (see next step) -- alternatively if you want the core library only then just runpip install burr.
Then, run the server and check out the demo projects:$burr2024-02-2311:43:21.249|INFO|burr.cli.__main__:run_server:88-Startingserveronport7241This will start a server and open up a browser window with a few demo projects preloaded for you to play with.Next, see the documentation forgetting started, and follow the example.
Then read through some of the concepts and write your own application!RoadmapWhile Burr is stable and well-tested, we have quite a few tools/features on our roadmap!Various efficiency/usability improvements for the core library (seeplanned capabilitiesfor more details). This includes:Fully typed state with validationFirst-class support for retries + exception managementMore integration with popular frameworks (LCEL, LLamaIndex, Hamilton, etc...)Cloud-based checkpointing/restart (save state to db and replay/warm start, backed by a configurable database)Tooling for hosted execution of state machines, integrating with your infrastructure (Ray, modal, FastAPI + EC2, etc...)If you want to avoid self-hosting the above solutions we're building Burr Cloud. To let us know you're interested
sign upherefor the waitlist to get access.ContributingWe welcome contributors! To get started on developing, see thedeveloper-facing docs.
Package: burrito
burrito, canonically pronouncedboar-eee-toe, is a Python framework for
wrapping and controlling command-line applications.What’s with the name?This tool allows developers to wrap command-line applications, just as burritos
wrap delicious foods. Both hide the potentially unsightly details.InstallationTo install burrito:pip install burritoRunning the testsTo run burrito’s unit tests:nosetestsThe pre-history of burritoburrito is derived from theapplication controller frameworkcode, which was originally added toPyCogentand
later moved toscikit-bio. The contributors and/or
copyright holders have agreed to make the code they wrote for PyCogent
available under the BSD license. The original authors of the application
controller framework code in PyCogent are Greg Caporaso
(@gregcaporaso), Sandra Smit,
Micah Hamady, and Rob Knight (@rob-knight).
Package: burrowkv
BurrowkvBurrowkv is a simple key-value store implementation in Python. It provides basic functionality to store and retrieve key-value pairs, as well as additional features such as JSON serialization and deserialization.FeaturesSet a value for a given key.Retrieve the value associated with a key.Delete a key-value pair.Check if a key exists in the store.Get a list of all keys.Get a list of all values.Get a list of all key-value pairs.Serialize the key-value store to JSON.Deserialize JSON into the key-value store.Installationpip install burrowkvUsagefrom burrowkv import burrowkv

# Create a new instance of burrowkv
store = burrowkv()

# Set a value for a key
store.set('name', 'John')

# Retrieve the value associated with a key
name = store.get('name')  # Returns 'John'

# Delete a key-value pair
store.delete('name')

# Check if a key exists
if store.contains('name'):
    print('Key exists')
else:
    print('Key does not exist')

# Get a list of all keys
keys = store.keys()  # Returns a list of keys

# Get a list of all values
values = store.values()  # Returns a list of values

# Get a list of all key-value pairs
items = store.items()  # Returns a list of (key, value) tuples

# Serialize the key-value store to JSON

json_data = store.to_json()

# Deserialize JSON into the key-value store
store.from_json(json_data)LicenseThis project is licensed under the MIT License. See the LICENSE file for more information.
Package: burrowts
BurrowTSThe BurrowTS is a Python library that provides a simple and efficient time series database for storing and retrieving time-stamped values.FeaturesInsert values into the time series database with an associated timestamp.Retrieve time series data for a given series name.Retrieve time series data for a given series name by timestamp range.Thread-safe operations using a lock.Data persistence using pickle.InstallationYou can install the BurrowTS using pip:pip install burrowtsUsageHere's an example of how to use the BurrowTS:fromburrowtsimportBurrowTSdb=BurrowTS()# Insert valuesdb.insert("cpu",12.3)db.insert("cpu",14.9)db.insert("mem",20.4)# Retrieve time series datacpu_data=db.get_series("cpu")print("CPU Data:",cpu_data)Data PersistenceThe BurrowTS uses pickle for data persistence. The database data is stored in a pickle file specified by thefile_pathparameter. The data is automatically saved to the file after each insertion operation.Thread SafetyThe BurrowTS ensures thread safety by using a lock. This allows for concurrent access from multiple threads while maintaining data integrity.ContributingContributions are welcome! If you have any ideas, suggestions, or bug reports, please open an issue or submit a pull request.LicenseThis project is licensed under theMIT License.
Package: burstfit
burstfitSpectro-temporal modeling of FRBsInstallationgitclonehttps://github.com/thepetabyteproject/burstfitcdburstfit
pipinstall-rrequirements.txt
pythonsetup.pyinstallDocumentationHave a look at ourdocsfor the documentation.TutorialsHere are sometutorial notebooksto get you started.Note:
To run the tutorial notebooks you would need to installjupyter.Citation
Package: burstH2MM
burstH2MMIntroductionburstH2MM is a package designed to make processing FRETBursts data with photon-by-photon hidden Markov Modeling (H2MM) easy to use, and to calculate things such as E, S, transition rates, and other dwell and model parameters, removing the need to manually recode such details each time.The basic units of burstH2MM are:BurstDatathe container of a set of photon streamsH2MM_listThe container for a divisor schemeH2MM_resutlA H2MM optimization. This is contains most analysis parameters. Things such as dwell E, dwell S, and dwell mean nanotimeWhile each class can be assigned to a new variable or list, all three classes keep a record of the object they create, and the object that created them. Therefore it is generally encouraged to simply work with the originating BurstData object and refer to all subfield through it following the appropirate referencing of attributes.DocumentationSee full documentation athttps://bursth2mm.readthedocs.ioInstallationThis package can be installed with$pipinstallburstH2MMBackgroundH2MM was developed byPirchi and Tsukanov et. al. J. Phys. Chem. B 2016, and extended inHarris et.al. Nat. Comm. 2022. This modeule requies the H2MM_C packaged introduced inHarris et.al., andFRETBursts, developed byIngariola et. al. Plos ONE 2016to make the process of anlaysis far easier for single molecule FRET data.When usingburstH2MMplease cite all three papers.
Package: burst-waveform
Burst waveformThis package hosts the python version of the burst waveform used in coherentWaveBurst(cWB) search.Installation from sourcemakeinstallUsageTheBurst-Waveformpackage provides three burst waveform models:SineGaussian,SineGaussianQ,
andWhiteNoiseBurstThe waveforms can be generated by calling the instance of the waveform model after initializing it with the desired
parameters.For example, to generate aSineGaussianQwaveform,fromburst_waveform.modelsimportSineGaussianQfrommatplotlibimportpyplotaspltparams={"amplitude":1.0,"frequency":300.0,"Q":9}model=SineGaussianQ(params)t,strain=model()plt.plot(t,strain)plt.show()ForWhiteNoiseBurstwaveform,fromburst_waveform.modelsimportWhiteNoiseBurstimportmatplotlib.pyplotaspltparams={'frequency':300,'bandwidth':50,'duration':0.005,'inj_length':1,'mode':1}WNB=WhiteNoiseBurst(params)t,wnb=WNB()plt.plot(t,wnb)plt.xlim(0.5-10*params['duration'],0.5+10*params['duration'])plt.show()
Package: bus
Bus - Python Json AggregatorPre-Alpha projectTakes json payloads and combines them by nesting one in the payload of another using a shared key.InstallationInstall with Pip:pipinstallbusUsagefrombussing.bussesimportBusBus().group(parent='PARENT JSON',child='CHILD JSON',keys=[("id","shapes")]Keys needs to be a list of tuples. The first element is the key ID to match results with,
and the second is the new name to list items as under the parent.ExamplesGiven:[{"id":"Apples","colours":["Red","Green"]},{"id":"Bananas","colours":["Yellow"]},{"id":"Mangos","colours":["Orange","Green"]}]And:[{"id":"Apples","round":true},{"id":"Bananas","round":false}]You can combine these results into one payload:[{"id":"Apples","colours":["Red","Green"],"shapes":{"round":true}},{"id":"Bananas","colours":["Yellow"],"shapes":{"round":false}},{"id":"Mangos","colours":["Orange","Green"]}]
Package: busbus
busbus is a platform for working with public transit data. It allows you to
query both realtime and scheduled arrivals as well as other information about
transit agencies.In addition to its Python interface, it provides an optional WSGI application
so you can use busbus’s data in any application with HTTP and JSON libraries.Documentation is currently very limited but we’re working on that. A demo of
using busbus is available as an asciicast:busbus was originally developed as a senior CS capstone project at theKU EECS
department.
Package: buscacep
O site dos Correios disponibiliza gratuitamente um ótimo serviço para busca online de CEPs.
Porém, essa é a única forma de acessá-lo: via página HTML.
Não existe, nem é exposta, nenhuma API que facilite a integração desse serviço com outras aplicações.Para possibilitar esse tipo de integração, criei o buscacep que nada mais é que um componente python
que abstrai a complexidade de:Fazer a requisição HTTP (GET) passando os parâmetros necessários e;Processar a resposta - extraindo os dados de CEP do HTML retornado.Internamente utilizo a biblioteca beautifulsoup4 para auxiliar no Web Scraping.
Package: buscemizer
DescriptionAdd Steve Buscemi’s beautiful facial features to facial photos!RequirementsPython 3.6+facial-recognitionpillownumpyInstallationbuscemizer can be installed via pip:pip install buscemizerUsageAfter installing buscemizer it can be executed from the command line:buscemizer <path to image to have Steve Buscemi's beautiful facial features added to>For additional help in using buscemizer run the following command:buscemizer --helpExampleAs an example lets buscemize Joe Biden.To do such we run the following command:buscemizer examples/biden.jpgAfter the buscemizing is completed, abiden-buscemi.jpgfile will be
created within the current working directory.If everything goes well it should look something like this…
Package: buscolite
BUSCOlite: simplified BUSCO analysis for gene predictionBUSCOlite can run the miniprot/Augustus mediated genome predictions as well as thepyhmmerHMM predictions using the BUSCO v9 or v10 databases. It also provides a python API to run busco analysis from within python, ie to be used inside the eukaryotic gene prediction pipeline Funannotate.This tool is not meant to be a replacment of BUSCO, for most general use cases you should continue to useBUSCOv5BUSCO models/lineages can be downloaded from the BUSCO site:v5,v4.  BUSCOlite does not provide an internal method to do this, as it is trivial to download the lineage you need from your organism(s) by following these links.There are limited dependencies with BUSCOlite:augustus(note: many versions on conda have non-functional PPX/--proteinprofile mode)miniprotpyhmmerpyfastxnatsortWhy?Funannotateuses BUSCO to find core conserved marker genes that it uses as a basis to train several ab-initio gene predictors. When BUSCO v2 came out it was python3 only and at that time funannotate was still python2, so I modified the BUSCOv2 source code to be compatible with python2 so it could be run within funannotate. Now BUSCOv5 is the current release, that has numerous bells and whistles that funannotate does not need (no knock against bells and whistles) but the real problem is that due to the large number of dependencies associated with these extra tools is that I cannot build a conda image that includes funannotate and BUSCOv5. So I re-wrote BUSCOv2 here so that it has limited dependencies and will make it easier to incorporate as a dependency of funannotate.  A side note is that themetaeukmethod that BUSCOv5 now uses as default does not produce complete gene models, in fact the protein sequences it outputs have lowercase sequences that are actually not found in your genome at all.  So for training ab-initio predictors, themetaeukmethod is not useful -- however, it is faster to get your simple stats on "how complete is my genome assembly".To install release versions use the pip package manager, like so:python -m pip install buscoliteTo install the most updated code in master you can run:python -m pip install git+https://github.com/nextgenusfs/buscolite.git
Package: buscophylo
BuscoPhylo is a free online pipeline for phylogenomic analysis using BUSCO. It quickly analyzes FASTA formatted genome sequences and provides ready-to-publish results. The user-friendly interface makes it easy to use for anyone.To access the BuscoPhylo API, you need to log in to the user dashboard and have an API token for authentication. Your API token can be found under your user name in the dashboard. To install the BuscoPhylo API, simply run “pip install buscophylo” in your terminal.To use the BuscoPhylo API, import the buscophylo module, initiate an instance of the BuscoPhylo class, and set your API token, project name, lineage, mode, and directory. Finally, run the run function. Example code:from buscophylo import BuscoPhylobuscophylo = BuscoPhylo()buscophylo.Token(“YOUR_TOKEN”)buscophylo.Project_Name(“Project_Name”)buscophylo.lineage(“Lineage”)buscophylo.mode(“Mode”)buscophylo.directory(“Directory”)buscophylo.Project_groupe(“outgroup”) # optionalbuscophylo.run()If you use the BuscoPhylo API in your work, please cite it in your publication to acknowledge its contribution. BuscoPhylo is also available on PyPI athttps://pypi.org/project/BuscoPhylo/.
Package: buser-django-instrumentation-sentry
buser-django-instrumentation-sentryProjeto com alguns utilitários para ajudar no envio de erros para o Sentry.O que tem aqui que pode ajudar no seu projeto?Rate-limiting de envio de erros usando REDISSanitizadores padrões para ajudar não enviar PII para o SentryComo usar?pip install buser-django-instrumentation-sentry
# coloca no seu requirements.in!E então no projeto inicializa o Sentry usando os utilitários disponíveis aqui.importsentry_sdkimportredisfrombuser_django_instrumentation_sentry.redis_dedup_integrationimportRedisDedupIntegrationfrombuser_django_instrumentation_sentry.sanitizeimportcreate_event_sanitizerredis_client=redis.StrictRedis()sentry_sdk.init(before_send=create_event_sanitizer(),integrations=[RedisDedupIntegration(redis_client)])
Package: buser-xml-to-dict
## InstallationRun the following to install:pip install buser-xml-to-dict## UsageCTE_XML = ‘/’.join([os.path.dirname(__file__), ‘pathtofile.xml’])
cte = XmlAdapter.from_xmlpath(CTE_XML)
cte[‘cteProc__CTe__infCte__ide__cUF’]
Package: buseswarsaw
# buseswarsaw PackagePython package containing tools for analysing data on buses in Warsaw.This package provides tools for:downloading data on locations of buses in Warsaw,downloading data on locations of bus stops,downloading schedule for a given line and bus stop,finding buses that exceeded 50 km/h for the given dataset,plotting data on the map,computing percentage of buses that exceeded 50 km/h near the given place,checking punctuality of buses of given line for given bus stop.
Package: busGal-api
# bus.gal-api 🚍[![GitHub license](https://img.shields.io/github/license/peprolinbot/bus.gal-api)](https://github.com/peprolinbot/bus.gal-api)
[![PyPI version](https://img.shields.io/pypi/v/busGal-api?label=pypi%20package)](https://pypi.org/project/busGal-api)
[![Upload Python Package](https://github.com/peprolinbot/bus.gal-api/actions/workflows/python-publish.yml/badge.svg)](https://github.com/peprolinbot/bus.gal-api/actions/workflows/python-publish.yml)Python API wrapper for [the galician public transport](https://www.bus.gal/) which uses the
associated
[app](https://play.google.com/store/apps/details?id=gal.xunta.transportepublico)’shttp API to get the inforamtion about buses, your card and your user
account. I got the endpoints using [mitmproxy](https://mitmproxy.org/).## 📜 DocumentationDocumentation can be found [here](https://peprolinbot.github.io/bus.gal-api). There are two main submodules:busGal_api.transportandbusGal_api.accounts, the first one has all the functions related to transportation and the second one allows you to manage cards and accounts, as the name implies.## 🔧 InstallationJust run:` bash pip install busGal_api `## ✅ Quick examplesThere are quick examples for both the submodules mentioned above in their__main__.pyand their docs.## ⚠️ DisclaimerThis project is not endorsed by, directly affiliated with, maintained
by, sponsored by or in any way officially related with la Xunta de
Galicia, the bus operators or any of the companies involved in the
[bus.gal](https://www.bus.gal/) website and the
[app](https://play.google.com/store/apps/details?id=gal.xunta.transportepublico).