Saravanan666/pypi-org huggingface dataset:
Package: bennellickeng.kitdrivers
Bennellick Engineering Limited Kit DriversThis python package consists of various driver classes used by BEL to control pieces of test equipment.Machine-wide install for development#!bash
pip install -U --user -e .This will install the package in 'editable' mode (-e), which means any changes made in this repository will be available immediately to all scripts importing the package. The above command only needs to be re-run if changes are made tosetup.py.UsageOnce installed, the packagebennellickengcan be imported and used. See theexamplesdirectory for examples of usage.As well as installing a python package some command line utilities are also installed:bel-scopegrabGrab screenshot of a scope over USB:#!bash
bel-scopegrab foobar
# foobar.png will have been createdReleasingThis project uses zest.releaser to manage packaging and releases. Simply run 'fullrelease' from within the pipenv.
Package: benparse
benparsebenparse is a bencode parser for Python 3. It is capable of reading and creatingbencoded filessuch as torrentsFeaturesSyntax is similar to built-in modules such asjsonandpickleHas an optional strict mode that will raise an error when it encounters non-fatal errors such as out-of-order dict keys or integers with leading zeros. This ensures that "round-tripping" bencoded data (loading bencoded data and then dumping it back to bencode) will never caused unexpected changesAble to change the character encoding used to encode/decode stringsFully typedUsageComplete usage documentation and examples are availablehere# Load a bencoded filewithopen('linux_distro.torrent','rb')asfile:torrent_dict=benparse.load(file)# Make changestorrent_dict[b'announce']=b'http://mirror.example.org:6969/announce'# Save a Python object as a bencoded filewithopen('linux_distro.torrent','wb')asfile:benparse.dump(torrent_dict,file)RequirementsPython 3.6+Typing Extensions(only for Python versions less than 3.8)InstallationInstall from PyPI:pip3installbenparseInstall from source:gitclonehttps://gitlab.com/adralioh/benparse.git
pip3install./benparseTestsTests are run using the built-inunittestmodule, andCoverage.pyis used to measure code coverageRun tests without measuring coverage:python3-munittestdiscovertestsRun tests and measure coverage:coveragerun-munittestdiscovertestsView the results:coveragereportGenerate a detailed report, outputted to./htmlcov:coveragehtmlBuilding documentationSphinx is used to build documentationBuild requirements:SphinxHow to build:cddocs
makehtml
Package: benstats
benstatsA Python package for calculating Benford's Law statistics on imagesTable of ContentsInstallationLicenseInstallationpip install benstatsUsageImporting the packageimportbenstatsRead an imageimage=benstats.read("path/to","image.png")Supported image formats: bmp, dib, jpeg, jpg, jpe, jp2, png, webp, pbm, pgm, ppm, pxm, pnm, sr, ras, tiff, tif, exr, hdr, picCalculate Benford's Law statisticsbenstats.benstats(image,channels=['rgb','gray'],scale=1,min=0,max=255)channels: list of channels to calculate statistics for. Possible values:rgb,hsv,gray,lab,luv,xyz,ycbcrscale: scale factor for the image. Ifscaleis less than 1, the image will be downsampled. Ifscaleis greater than 1, the image will be upsampled.min: new range min to map pixel values into. Default: 0max: new range max to map pixel values into. Default: 255Returns a dictionary of channelwise statistics.Plotting Benford's Law statisticsbenstats.benplot(image,channels=['rgb'],scale=1,min=0,max=255)Same parameters as above.Licensebenstatsis distributed under the terms of theMITlicense.Built by @gv-sh @bhaumikdebanshu
Package: bent
Python Library for Named Entity Recognition (NER) and Linking (NEL) in the biomedical domain.BENT can be used for:Named Entity Recogniton (NER)Named Entity Linking (NEL)Named Entity Recognition and Linking (NER+NEL)Access the fulldocumentation.Citation:Pedro Ruas and Francisco M. Couto. `Nilinker: attention-based approach to nil entity linking.
Journal of Biomedical Informatics, 132:104137, 2022.
doi: https://doi.org/10.1016/j.jbi.2022.104137.InstallationTo use the current version of BENT it is required:OS: Debian>=11/Ubuntu>=20.04Python >=3.7, <=3.10.13Required space between 5.5 GB - 10 GB
* Dependencies: 2.5 GB
* Data: between 3.0 GB (base) or 7.5 GB (if you use all available knowledge bases for Named Entity Linking)NOTE: Python Docker images (3.7 to 3.9) inDocker Hubhave Debian 11 as the base OS.Install the BENT package using pip:pip install bentThe following knowledge bases can be configured:‘medic’ (MEDIC)‘do’ (Disease ontology)‘chebi’ (ChEBI ontology)‘ctd_chem’ (CTD-Chemicals)‘ncbi_gene’ (NCBI Gene)‘ctd_gene’ (CTD-GENES)‘ncbi_taxon’ (NCBI Taxonomy)‘go_bp’ (Gene Ontology-Biological Process)‘ctd_anat’ (CTD-Anatomy)‘fma’ (Foundation model of Anatomy)‘uberon’ (UBERON ontology)‘go_cc’ (Gene Ontology-Cellular Component)‘cell_ontology’ (Cell Ontology)‘cellosaurus’ (Cellosaurus)After the pip installation, it is required a further step to install non-Python dependencies and to download the necessary data. Run in the command line:bent_setupOnly the default knowledge bases ‘medic’ and ‘chebi’ will be available at this point.To disable annoyng messages in the terminal run:export TF_CPP_MIN_LOG_LEVEL='3'You can download more knowledge bases later by specifying the desired knowledge bases among the ones that are available:python -c "from bent.get_kbs import get_additional_kbs;get_additional_kbs([<kb1>, <kb2>])"Example: to download the NCBI Taxonomy and the NCBI Gene run:python -c "from bent.get_kbs import get_additional_kbs;get_additional_kbs(['ncbi_taxon', 'ncbi_gene'])"Get startedTo apply the complete pipeline of entity extraction (NER+NEL) set the arguments:recognize: indicate that the NER module will be applied (‘True’)link: indicate that the NEL module will be applied (‘True’)types: entity types to recognize and the respective target knowledge bases.in_dir: directory path containing the text files to be annotated (the directory must contain text files exclusively)out_dir: the output directory that will contain the annotation filesExample:import bent.annotate as bt

bt.annotate(
        recognize=True,
        link=True,
        types={
         'disease': 'medic'
         'chemical': 'chebi',
         'gene': 'ncbi_gene',
         'anatomical': 'uberon',
         'cell_line': 'cellosaurus',
         'bioprocess': 'go_bp'
         },
        in_dir='input/txt/',
        out_dir='output/nel/'
)It is also possible to apply the pipeline (NER+NEL) to a string or a list or strings instantiated in the execution script.To see more usage examples, access thedocumentation.
Package: benten-meta
benten-metaBENTEN metadata toolSummaryThis provides metadata tools for benten metadata format.BENTEN provides two ways to present metadata.metadata with flat key, json  ( "@" is used to provide flat key to present hierarchical metadata){
    "@data_info@identifier@pid":"facility.xxxxx",
    "@data_info@identifier@proposal_number":"xxxxx"
}hierarchical metadata, yamldata_info:
  identifier:
    pid: facility.xxxxx
    proposal_number: xxxxxThis tool can convert metadata from json to yaml, or from yaml to json.Install$ pip install benten-metaUsageconvert metadata from yaml to json$　benten-meta.py convert_yaml2json example/metadata_hierarchy.yml test_flat.json
### benten-meta convert_yaml2json ###
==> convert from example/metadata_hierarchy.yml into test_flat.jsonconvert metadata from json to yaml$ benten-meta.py convert_json2yaml example/metadata_flat.json test_hierarchy.yml 
### benten-meta convert_json2yaml ###
==> convert from example/metadata_flat.json into test_hierarchy.ymlLicenseApache License 2.0AuthorCopyright (C) 2021 Takahiro Matsumoto (matumot@spring8.or.jp)
Package: bentley-ottmann
bentley_ottmannIn what followspythonis an alias forpython3.7orpypy3.7or any later version (python3.8,pypy3.8and so on).InstallationInstall the latestpip&setuptoolspackages versionspython-mpipinstall--upgradepipsetuptoolsUserDownload and install the latest stable version fromPyPIrepositorypython-mpipinstall--upgradebentley_ottmannDeveloperDownload the latest version fromGitHubrepositorygitclonehttps://github.com/lycantropos/bentley_ottmann.gitcdbentley_ottmannInstall dependenciespython-mpipinstall-rrequirements.txtInstallpythonsetup.pyinstallUsageWith segments>>>fromground.baseimportget_context>>>context=get_context()>>>Point,Segment=context.point_cls,context.segment_cls>>>unit_segments=[Segment(Point(0,0),Point(1,0)),...Segment(Point(0,0),Point(0,1))]we can check if they intersect>>>frombentley_ottmann.planarimportsegments_intersect>>>segments_intersect(unit_segments)TrueWith contours>>>Contour=context.contour_cls>>>triangle=Contour([Point(0,0),Point(1,0),Point(0,1)])>>>degenerate_triangle=Contour([Point(0,0),Point(2,0),Point(1,0)])we can check if they are self-intersecting or not>>>frombentley_ottmann.planarimportcontour_self_intersects>>>contour_self_intersects(triangle)False>>>contour_self_intersects(degenerate_triangle)TrueDevelopmentBumping versionPreparationInstallbump2version.Pre-releaseChoose which version number category to bump followingsemver
specification.Test bumping versionbump2version--dry-run--verbose$CATEGORYwhere$CATEGORYis the target version number category name, possible
values arepatch/minor/major.Bump versionbump2version--verbose$CATEGORYThis will set version tomajor.minor.patch-alpha.ReleaseTest bumping versionbump2version--dry-run--verbosereleaseBump versionbump2version--verbosereleaseThis will set version tomajor.minor.patch.Running testsInstall dependenciespython-mpipinstall-rrequirements-tests.txtPlainpytestInsideDockercontainer:withCPythondocker-compose--filedocker-compose.cpython.ymlupwithPyPydocker-compose--filedocker-compose.pypy.ymlupBashscript:withCPython./run-tests.shor./run-tests.shcpythonwithPyPy./run-tests.shpypyPowerShellscript:withCPython.\run-tests.ps1or.\run-tests.ps1cpythonwithPyPy.\run-tests.ps1pypy
Package: bento2seldon4recsys
bento2seldon4recsysExtension of bento2seldon for RecSys.Installationpipinstall-Ubento2seldon4recsysor install withPoetrypoetryaddbento2seldon4recsysMakefile usageMakefilecontains a lot of functions for faster development.1. Download and remove PoetryTo download and install Poetry run:makepoetry-downloadTo uninstallmakepoetry-remove2. Install all dependencies and pre-commit hooksInstall requirements:makeinstallPre-commit hooks coulb be installed aftergit initviamakepre-commit-install3. CodestyleAutomatic formatting usespyupgrade,isortandblack.makecodestyle# or use synonymmakeformattingCodestyle checks only, without rewriting files:makecheck-codestyleNote:check-codestyleusesisort,blackanddarglintlibrary4. Code securitymakecheck-safetyThis command launchesPoetryintegrity checks as well as identifies security issues withSafetyandBandit.makecheck-safety5. Type checksRunmypystatic type checkermakemypy6. TestsRunpytestmaketest7. All lintersOf course there is a command torulerun all linters in one:makelintthe same as:maketest&&makecheck-codestyle&&makemypy&&makecheck-safety8. Dockermakedocker-buildwhich is equivalent to:makedocker-buildVERSION=latestRemove docker image withmakedocker-removeMore informationabout docker.9. CleanupDelete pycache filesmakepycache-removeRemove package buildmakebuild-removeOr to remove pycache, build and docker image run:makeclean-all📈 ReleasesYou can see the list of available releases on theGitHub Releasespage.We followSemantic Versionsspecification.We useRelease Drafter. As pull requests are merged, a draft release is kept up-to-date listing the changes, ready to publish when you’re ready. With the categories option, you can categorize pull requests in release notes using labels.List of labels and corresponding titlesLabelTitle in Releasesenhancement,feature🚀 Featuresbug,refactoring,bugfix,fix🔧 Fixes & Refactoringbuild,ci,testing📦 Build System & CI/CDbreaking💥 Breaking Changesdocumentation📝 Documentationdependencies⬆️ Dependencies updatesYou can update it inrelease-drafter.yml.GitHub creates thebug,enhancement, anddocumentationlabels for you. Dependabot creates thedependencieslabel. Create the remaining labels on the Issues tab of your GitHub repository, when you need them.🛡 LicenseThis project is licensed under the terms of theApache Software License 2.0license. SeeLICENSEfor more details.📃 Citation@misc{bento2seldon4recsys,author={deeplearningbrasil},title={Extension of bento2seldon for RecSys.},year={2021},publisher={GitHub},journal={GitHub repository},howpublished={\url{https://github.com/deeplearningbrasil/bento2seldon4recsys}}}CreditsThis project was generated withpython-package-template
Package: bentobuild
bentobuildA helper which provides a simple api to launching pods to create docker images from BentoML Services in a Kubernetes clister, by making use of BentoMLsYataiService.This does not use thebentoml containerizecommand because it requires Docker daemon and build containers most commonly wont have a running a docker daemon. Instead, this package creates a custom Kubernetes Job, which usesbentoml retrievealongsideKaniko executorto build the BentoML context and artifacts into a docker image and push it to your desired docker image and tag.The resulting image can be served via KFServing inferenceservice or via the bundled serving experiment.The builder schedules a standard Kubernetes Job with several containers to build the image.YataiService RequiredThis project really only makes sense when using BentoML with aYataiService, as multiple pods will need to access the model storage backend.I would suggest running theYataiServiceso it is only open to local cluster traffic, and refer to it via itscluster.localdomain name.BuilderIn the example below, the builder will create a new Kubernetes Job, which will produce an image, tag it and push it the registry.from bentobuild.job import BentoJobBuilder

builder = bentobuild.BentoJobBuilder()

# safe_build requires a BentoML Service ID, an image tag and your build namespace.
# This is the namespace where your docker credentials need to exist - see below.
builder.safe_build('FastaiDemo:20201105133154_04F821', 'iancoffey/mydemo:latest', 'test1')

# resources begin running

builder.status() # prints some output from the Job statusInstallationpip install bentobuildDocker CredentialsIt is important to configure Docker credentials for the builder to use to push to your desired repo.To do this, the project supports mounting a configmap containting a Dockerconfig.jsoninto the build environment.See theKaniko documentationfor more info on how to format and create this secret.
Package: bentoctl
🚀 Fast model deployment on any cloudbentoctl helps deploy any machine learning models as production-ready API endpoints on the cloud, supporting AWS SageMaker, AWS Lambda, EC2, Google Compute Engine, Azure, Heroku and more.👉Join our Slack community today!✨ Looking deploy your ML service quickly? You can checkoutBentoML Cloudfor the easiest and fastest way to deploy your bento. It's a full featured, serverless environment with a model repository and built in monitoring and logging.HighlightsFramework-agnostic model deployment for Tensorflow, PyTorch, XGBoost, Scikit-Learn, ONNX, and many more viaBentoML: the unified model serving framework.Simplify the deployment lifecycle of deploy, update, delete, and rollback.Take full advantage of BentoML's performance optimizations and cloud platform features out-of-the-box.Tailor bentoctl to your DevOps needs by customizing deployment operator and Terraform templates.Getting Started💻 Quickstart Guide- Deploy your first model to AWS Lambda as a serverless API endpoint.📖 Core Concepts- Learn the core concepts in bentoctl.🕹️ Operators List- List of official operators and advanced configuration options.💬 Join Community Slack- Get help from our community and maintainers.Supported Platforms:AWS LambdaAWS SageMakerAWS EC2Google Cloud RunGoogle Compute EngineAzure Container InstancesHerokuUpcomingAzure FunctionsCustom OperatorUsers can built custom bentoctl plugin from thedeployment operator templateto deploy to cloud platforms not yet supported or to internal infrastructure.If you are looking for deploying withKubernetes, check outYatai: Model deployment at scale on Kubernetes.Installationpipinstallbentoctl| 💡 bentoctl designed to work with BentoML version 1.0.0 and above. For BentoML 0.13 or below, you can use thepre-v1.0branch in the operator repositories and follow the instruction in the README. You can also check out the quickstart guide for 0.13here.CommunityTo report a bug or suggest a feature request, useGitHub Issues.For other discussions, useGithub Discussionsunder theBentoML repoTo receive release announcements and get support, join us onSlack.ContributingThere are many ways to contribute to the project:Create and share new operators. Usedeployment operator templateto get started.If you have any feedback on the project, share it with the community inGithub Discussionsunder theBentoML repo.Report issues you're facing and "Thumbs up" on issues and feature requests that are relevant to you.Investigate bugs and reviewing other developer's pull requests.Usage ReportingBentoML and bentoctl collects usage data that helps our team to
improve the product. Only bentoctl's CLI commands calls are being reported. We
strip out as much potentially sensitive information as possible, and we will
never collect user code, model data, model names, or stack traces. Here's thecodefor usage tracking. You can opt-out of
usage tracking by setting environment variableBENTOML_DO_NOT_TRACK=True:exportBENTOML_DO_NOT_TRACK=TrueLicenceElastic License 2.0 (ELv2)
Package: bento-dash
BentoCreate Plotly Dash apps via templatesThis GIF shows the ideal Bento experience, how you can add components to a dashboard in real time. Adding two extra controls, fixing up the layout, and finally applying a dark theme were all simple, drop-in changes.Bento is a templating engine built onPlotly Dash. It lets you
write a high-level description of your desired interactive dashboard and generates
the application code for you. Like itsnamesake,
Bento focuses on convenience and organization.  By providing a set of reusable
building blocks and abstracting away some of the more complicated aspects, it
aims to flatten the learning curve of dashboarding!FeaturesWrite 10x fewer lines of code for your appEasily control the dashboard layout via a grid systemLeverage a library of pre-built compound objects (Bento's 'banks')CSS-free experience -- simple theming and styling support, CSS is templated awayOut-of-the-box support for multi-page dashboards with an appbarManage deployments withBento BuilderEncourage good coding practices, decoupling data prep and visualizationGalleryFor some example dashboards, I've put together asmall gallery.
You can click through the live examples linked in the readme and compare to the
descriptors located in each of the associated folders in the repo.QuickstartDependencies: Python 3.7+Bento is available on PyPI, and the latest version can be installed with:pip3 install bento-dashTo make sure everything is working, try running the demo app:bento-demoAnd navigate in your browser tolocalhost:8050.Developing with BentoIf you're interested in creating and deploying a Bento dashboard, I recommend setting
up a Docker-friendly environment. I created a repo that can get you going calledBento Builder. Some extra details are
provided in the Bento Builder readme.Contributing to BentoAs an early stage product, honest and direct feedback is extremely valuable.
Don't hesitate to open an issue with suggestions until another forum is set up.
Package: bento-headless
[alpha] A Git-aware CLI for running semgrep patterns in the developer and CI workflow.Installation·Usage·Help & CommunityInstallationRequiresPython 3.6+andDocker 19.03+. It runs on macOS and Linux.In a Git project directory:$pip3installbento-headlessUsageUpgrading$pip3install--upgradebento-headlessCommand line options$ bentoh --help
Usage: bentoh [OPTIONS] COMMAND [ARGS]...

Options:
  -h, --help  Show this message and exit.
  --version   Show the version and exit.

Commands:
  archive  Suppress current findings.
  check    Checks for new findings.

  To get help for a specific command, run `bentoh COMMAND --help`Run customsemgrepchecks on staged diffsSeesemgrep Configurationfor how to write custom rule filesvi .bento/semgrep.yml
bentoh checkFormat output as JSONbentoh check -f jsonRun on file system current statebentoh check --allRun on staged diffs in a directorybentoh check srcIgnore current findingsbentoh archiveRun public semgrep checks on staged diffsBENTO_REGISTRY=r/r2c.python bentoh checkRun checks from extensionsbentoh check -t gosec -t r2c.registry.latestExit codesbentoh checkmay exit with the following exit codes:0: Bento ran successfully and found no errors2: Bento ran successfully and found issues in your code3: Bento or one of its underlying tools failed to runExtensionsbentohships with the following extensions:ExtensionDescriptionbanditFinds common security issues in Python codedlintA tool for encouraging best coding practices and helping ensure Python code is secureeslintIdentifies and reports on patterns in JavaScript and TypeScriptflake8Finds common bugs in Python codegosecFinds security bugs in Go codehadolintFinds bugs in Docker files (requires Docker)r2c.boto3Checks for the AWS boto3 library in Pythonr2c.flaskChecks for the Python Flask frameworkr2c.jinjaFinds common security issues in Jinja templatesr2c.registry.latestRuns checks from r2c's check registry (experimental; requires Docker)r2c.requestsChecks for the Python Requests frameworkshellcheckFinds bugs in shell scripts (requires Docker)Help and communityNeed help or want to share feedback? We’d love to hear from you!Email us atsupport@r2c.devJoin #general in ourcommunity SlackFile an issueorsubmit a feature requestdirectly on GitHubWe’re constantly shipping new features and improvements.License and legalPlease refer to theterms and privacy document.Copyright (c)r2c.
Package: bento-sts
Welcome to bento-stsThis is a flask-based implementation of the Simple Terminology Service (STS) for the Bento Metadatabase (MDB).Install$ git clone https://github.com/CBIIT/bento-sts.git
$ cd pysts
$ virtualenv sts-venv
$ source sts-venv/bin/activate
$ pip install -r requirements.txt
$ flask runDependenciesbento-stsrequires a Neo4j-basedMDB.