Saravanan666/pypi-org huggingface dataset:
Package: tox-extras
tox-extrasA tox plugin to install extras directly frompyproject.tomlinto a testenvQuick startInstall it withpip install tox-extrasAdd it torequiresin the[tox]section of yourtox.ini[tox]
min_version = 4.0
requires = tox-extrasSay you have a lint extra inpyproject.tomlwhich you want to use in a
testenv:[project.optional-dependencies]
lint = ["black==23.3.0"]In yourtox.initestenv sections you can write[testenv:lintonly]
skip_sdist = true
skip_install = true
tox_extras = lint
commands = black --check example.pyand this will install all deps from the "lint" extra into the testenv without
installing your package or any of its deps.MotivationTox has built-in support for installing extras using theextrastestenv config
option, but this does not work when combined withskip_install.This plugin adds atox_extrasoption to the toxEnvConfigSetand installs
the extras named in this option into the testenv directly frompyproject.tomlwithout installing the package.This would be especially valuable when we want to usepyproject.tomlas a
single source of truth for our build, install, and dev dependencies (so puttingdepsintox.iniis out of the question), but at the same time we don't want
to "waste time" building and installing our package (and maybe its deps in a
first-time tox run, e.g., in CI) into a testenv that only runs a linter (and
therefore does not depend at all on the package or any deps being installed).Seehttps://github.com/tox-dev/tox/issues/2301for the corresponding feature
request in tox.Seehttps://github.com/pypa/pip/issues/4783#issuecomment-343771222for
commentary about the possible advantages of keeping all dependencies in one
place.LimitationsThis plugin explicitly parsespyproject.toml, so it will not work with
projects that define extras insetup.py.
Package: toxgen
Produces a tox.ini file from a template config file.The template config file is a standard tox.ini file with additional sections.
Theses sections will be combined to create new testenv: sections if they do
not exists yet.The added sections are:[axes]options:axis1name = value1(*)[,value2(*)[, ...]]
axis2name = value1(*)[,value2[, ...]]In this section, a list of test axes are given and for each of them a
list of possible values.A tailing ‘*’ on a value means it is this axis default value. Hence it can
be set on only one value.
The default value will create additional sections with this axis value
removed from the section name (see below)Example:To test a lib against different python version with and without
‘lxml’:[axes]
python = py25,py32
lxml = lxml*,nolxmlThis will generate the following [testenv:] sections:[testenv:py25-lxml]
# ...

[testenv:py25]
# A copy of testenv:py25-lxml

[testenv:py25-nolxml]
# ...

[testenv:py32-lxml]
# ...

[testenv:py32]
# A copy of testenv:py27-lxml

[testenv:py32-nolxml]
# ...[axis:name]The default options for an axis.Any option can be added, and if not overridden for a specific value,
combined with the same option in the other axis[axis:name:value]Options for a specific axis value.The only option that will be interpreted by gentox is ‘constraints’, a
multi-lines option that allow to exclude other axis values.For example, if we want not to test py25 without lxml:[axis:lxml:nolxml]
constraints=
    !python:py25The other options will be combined.Complete example:[tox]
envlist = py25-nolxml,py32

[axes]
python = py25,py32
lxml = lxml*,nolxml

[axis:python]
deps =
    six

[axis:python:py25]
basepython=python2.5

[axis:python:py32]
basepython=python3.2

[axis:lxml:nolxml]
constraints =
    !python:py25

[axis:lxml:lxml]
deps =
    lxmlThis will generate the following tox file:[tox]
envlist = py25-nolxml,py32

[testenv:py25-lxml]
deps =
    six
    lxml
basepython = python2.5

[testenv:py25]
deps =
    six
    lxml
basepython = python2.5

[testenv:py32-lxml]
deps =
    six
    lxml
basepython = python3.2

[testenv:py32]
deps =
    six
    lxml
basepython = python3.2

[testenv:py32-nolxml]
deps =
    six
basepython = python3.2RunningUsage: toxgen.py [options]

Options:
  -h, --help            show this help message and exit
  -i FILE, --input=FILE
                        input template file to process [default: tox-tmpl.ini]
  -o FILE, --output=FILE
                        output file to generate [default: tox.ini]
  -r, --rewrite         rewrite [tox] envlist [default: False]

Produce a tox.ini file from a template config file.  The template config file
is a standard tox.ini file with additional sections. Theses sections will be
combined to create new testenv: sections if they do not exists yet.
Package: tox-gh
tox-ghtox-ghis a tox plugin which helps running tox on GitHub Actions with multiple different Python versions on multiple
workers in parallel.FeaturesWhen running tox on GitHub Actions, tox-ghdetects which environment to run based on configurations andprovides utilities such asgrouping log lines.UsageAdd configurations under[gh]section along with your tox configuration.Installtox-ghpackage in the GitHub Actions workflow before runningtoxcommand.ExamplesBasic ExampleAdd[gh]section to the same file as tox configuration. If you're usingtox.ini:[gh]python=3.12=py3123.11=py311, type3.10=py3103.9=py393.8=py383.7=py37This will run different set of tox environments on different python versions set up via GitHubsetup-pythonaction:on Python 3.7 job, tox runspy37environment,on Python 3.8 job, tox runspy38environment,on Python 3.9 job, tox runspy39environment,on Python 3.10 job, tox runspy310environment,in Python 3.11 job, tox runspy311andtypeenvironments,on Python 3.12 job, tox runspy312environment.Workflow Configuration.github/workflows/check.yml:name:checkon:push:pull_request:schedule:-cron:"08***"concurrency:group:check-${{ github.ref }}cancel-in-progress:truejobs:test:name:test with ${{ matrix.py }} on ${{ matrix.os }}runs-on:${{ matrix.os }}strategy:fail-fast:falsematrix:py:-"3.12"-"3.11"-"3.10"-"3.9"-"3.8"-"3.7"os:-ubuntu-latest-macos-latest-windows-lateststeps:-uses:actions/checkout@v3with:fetch-depth:0-name:Setup python for test ${{ matrix.py }}uses:actions/setup-python@v4with:python-version:${{ matrix.py }}-name:Install toxrun:python -m pip install tox-gh>=1.2-name:Setup test suiterun:tox -vv --notest-name:Run test suiterun:tox --skip-pkg-installFAQWhen a list of environments to run is specified explicitly via-eoption orTOXENVenvironment variabletox-ghrespects the given environments and simply runs the given environments without enforcing its configuration.The plugin only activates if the environment variableGITHUB_ACTIONSistrue.
Package: toxic
.. raw:: html<div align="center">.. raw:: html</div>Intro-----**Toxic** is an open source software library for machine learningsecurity. It contains tools for adversarial example generation andprovides a framework for building new types of attack methods.Currently in the dev stage.Attacks-------Available attack algorithms implemented in Toxic:-  Fast Gradient Methods (FGM/FGSM)```Tutorial`` </tutorial/source/fgsm.ipynb>`__-  Basic Iterative```Tutorial`` </tutorial/source/basic_iterative.ipynb>`__-  Momentum Iterative```Tutorial`` </tutorial/source/momentum_iterative.ipynb>`__-  DeepFool-  Universal Adversarial Perturbation (UAP)-  Jacobian-based Saliency Map Approach (JSMA)-  One Pixel Attack-  LBFGS-  Carlini Wagner L2-  Carlini Wagner L-inf-  Feature Adversaries-  Boundary Attack-  Elastic Net-  Natural Adversarial Examples (NAE)The Team~~~~~~~~Toxic is a community driven project. The project was initiated bymachine learning security team @ `KakaoBrain <kakaobrain.com>`__... |license| image:: https://img.shields.io/github/license/mashape/apistatus.svg
Package: toxicbl
Welcome to toxicbl.pythis PyPi package helps you get info of bots , users and post data about user
/ server count with your token onToxic Bot ListGetting startedYou need to import the module firstfromtoxicblimportbots# or usersAn example about scraping info for bots (Same can be done with users)bots.get_info('your_id')# returns a usable info objectAn example about updating your bot's info (discord.py used)fromtoxicblimportdata@client.eventasyncdefon_ready()data.update({'token':'your_token','serversCount':str(len(client.servers)),'usersCount':str(len(client.users))})Bot Info ObjectReturns an object containing:bot_tag:String# Bot's tagavatar_url:String# Bot avatarUrllibrary:String# Library of botprefix:String# Prefix of botshort_description:String# Short description of bot in TBL sitelong_description:String# Long description of bot in TBL site (contains markdown & html)owner_tag:String# Full tag of ownerauthorize_link:String# Invite link of the botserver_count:String:Numberofserversuser_count:String:NumberofusersUser Info ObjectReturns an object containing:biography:String# User's biography if setavatar_url:String# User's avatar urlusername:String# User's usernamenum_of_bots:Integer# Number of bots created by user
Package: toxicityclassifier
ToxicityClassificatorModule for predicting toxicity messages in Russian and EnglishUsage examplefromtoxicityclassifierimport*classifier=ToxicityClassificator()print(classifier.predict(text))# (0 or 1, probability)print(classifier.get_probability(text))# probabilityprint(classifier.classify(text))# 0 or 1WeightsWeight for classification (if probability >= weight => 1 else 0)classifier.weight=0.5Weight for language detection (English or Russian)if the percentage of the Russian language >= language_weight, then the Russian model is used, otherwise the English oneclassifier.language_weight=0.5
Package: toxic-proxy
Toxic ProxyToxic Proxy is an asyncio-based TCP proxy designed for network resilience testing. This allows you to simulate network conditions like latency, bandwidth limitations, and other issues to test how your application behaves under different scenarios. Whether you're working with microservices or just need to test your network reliability, Toxic Proxy provides a flexible way to introduce network anomalies for better resilience testing.FeaturesSimulate network latencyLimit bandwidthEasy to integrate with Python applicationsUses asyncio for high performanceInstallationInstall Toxic Proxy using pip.pipinstall--upgradetoxic_proxyQuick StartUsing with CassandraHere's an example that shows how to use Toxic Proxy with a Cassandra cluster.importasynciofromaiocassandraimportaiosessionfromcassandra.clusterimportClusterfromtoxic_proxyimporttoxic_proxy# Create a proxy with latencyproxy=toxic_proxy(destination=('<cassandra-ip>',9042),latency=5,port=9043)# Connect to Cassandra through the proxycluster=Cluster(['0.0.0.0:9043'])session=cluster.connect()# ... your code here ...Simplified ExampleThis example demonstrates a simple use case to limit bandwidth when connecting to google.com.importasynciofromtoxic_proxyimporttoxic_proxy# Create a proxy with bandwidth limitproxy=toxic_proxy(destination=('google.com',80),bandwidth_rate_kb=0.5,port=8888)loop=asyncio.get_event_loop()server=loop.run_until_complete(proxy)print(f'Serving on{server.sockets[0].getsockname()}')try:loop.run_forever()exceptKeyboardInterrupt:pass# Close the serverserver.close()loop.run_until_complete(server.wait_closed())loop.close()TestingTo test, you can use curl to make a request through the proxy.curl-v0.0.0.0:8888ContributingWe welcome contributions! If you find a bug or have a feature request, please open an issue. If you want to contribute code, feel free to open a pull request.LicenseThis project is licensed under the MIT License. See the LICENSE file for details.
Package: toxicTrig
Toxic TriggersToxic Triggers is a Python package that provides access to a dataset of text triggers that have been categorized as offensive or harmless to minorities. This package can be useful for researchers and developers who want to understand how offensive language can affect marginalized groups and how it can be detected and prevented.FeaturesAccess to a dataset of text triggers categorized as offensive or harmless to minoritiesProvides easy access to subsets of the dataset based on categorizationBuilt with Pandas for easy data manipulationAnalyze the text for the presence of toxic triggersInstallationTo install the package, you can usepip install toxicTrigUsageHere's an example of how to use the package:fromtoxicTrigimporttoxicTrigimportpandasaspd#type: ignoreimporttimedf=pd.read_csv("example_data/ND_founta_trn_dial_pAPI.csv")text=df["tweet"].tolist()# A list of strings as the inputtt=toxicTrig()start_time=time.time()tt.text_analysis(text,batch_size=100)end_time=time.time()time_taken=round(end_time-start_time,2)print("Total time taken: ",time_taken," seconds")# Count tokens in texttotal_tokens=sum([len(t.split())fortintext])print("Total tokens in text: ",total_tokens)ContributionInstall dev optionspipinstall-e".[dev]"mypy--install-types--non-interactivetoxicTrig
pipinstallpre-commit
pre-commitinstallNew branch for each featuregit checkout -b feature/feature-nameand PR tomainbranch.Before committingRunpytestto make sure all tests pass (this will ensure dynamic typing passed with beartype) andmypy --strict .to check static typing.
(You can also runpre-commit run --all-filesto run all checks)CitationIf you use this package in your research, please cite the following paper:@inproceedings{zhou-etal-2020-debiasing,title={Challenges in Automated Debiasing for Toxic Language Detection},author={Zhou, Xuhui and Sap, Maarten and Swayamdipta, Swabha and Choi, Yejin and Smith, Noah A.},booktitle={EACL},year={2021},}LicenseThis package is released under the MIT License. See the LICENSE file for more details.CreditsThis package was developed by Xuhui Zhou and Maarten Sap.
Package: toxine
RuMor: Russian Morphology projectToxine: a tiny python NLP library for Russian text preprocessingA part ofRuMorproject. It contains pipeline for preprocessing and
tokenization texts inRussian. Also, it includes preliminary entity tagging.
Highlights are:Extracting emojis, emails, dates, phones, urls, html/xml fragments etc.Tagging/removing tokens with unallowed symbolsNormalizing punctuationTokenization (viaNLTK)RussanWikipediatokenizerbratannotations supportInstallationpipToxinesupportsPython 3.5or later. To install it viapip, run:$pipinstalltoxineIf you currently have a previous version ofToxineinstalled, use:$pipinstalltoxine-UFrom SourceAlternatively, you can also installToxinefrom source of thisgit
repository:$gitclonehttps://github.com/fostroll/toxine.git
$cdtoxine
$pipinstall-e.This gives you access to examples that are not included to thePyPIpackage.SetupToxineusesNLTKwithpunktdata downloaded. If you didn't do it yet,
startPythoninterpreter and execute:>>>importnltk>>>nltk.download('punkt')NB:If you plan to use methods forbratannotations renewal, you need to
install thepython-Levenshteinlibrary.
See more on thebratannotations supportpage.UsageText PreprocessorWrapper for tokenizedWikipediabratannotations supportExamplesYou can find them in the directoryexamplesof ourToxinegithub
repository.LicenseToxineis released under the BSD License. See theLICENSEfile for
more details.
Package: tox-ini-fmt
tox-ini-fmtapply a consistent format totox.inifilesinstallationpip install tox-ini-fmtas a pre-commit hookSeepre-commitfor instructionsSample.pre-commit-config.yaml:-repo:https://github.com/tox-dev/tox-ini-fmtrev:"1.1.0"hooks:-id:tox-ini-fmtargs:["-p","fix_lint,type"]cliConsult the help for the latest usage:$tox-ini-fmt--helpusage: tox-ini-fmt [-h] [-s] [-p toxenv] tox_inipositional arguments:tox_ini       tox ini file to formatoptional arguments:-h, --help    show this help message and exit-s, --stdout  print the formatted text to the stdout (instead of update in-place)-p toxenv     tox environments that pin to the start of the envlist (comma separated)what does it do?It does notFormat any other section besidetox/testenv:*(other than put this sections to the end of the file)Generalbooleanfields are normalized totrueorfalseall fields are stripped of white space on both endvalues that contain a list are split one value per line (PR/merge friendly)indent multi-line values by four spaces, and start on new linesubstitutions within multi-line (excludingcommands) are moved to the start of the list (order kept)Ordering of sectionsApplies the following section order:toxtestenvtestenv:*-py/pypyenvs are ordered in decreasing order by python version, then apply the order defined withinenvlistpart oftoxsection, you can pin tox elements to the start by using the-pflagany other section defined within the filetoxsectionOrder by:envlist- multi-line, start withpyenvs in decreasing python order, then same withpypy, then everything elseisolated_build-booleanfieldskipsdist-booleanfieldskip_missing_interpreters-booleanfieldminversiontestenvsectionOrder by:descriptionpassenv- multi-line, one environment name to pass per line, sorted by namesetenv- multi-line, one environment name-value to set per line in format ofkey=value, sorted by key+valuebasepythonskip_install-booleanfieldusedevelop-booleanfielddeps- multi-line, order by package name (but keep dependencies with package names separate at end), normalize
format to remove extra spacesextras- multi-line, one extra env per lineparallel_show_output-booleanfieldcommands- one command per line, commands that wrap over multiple lines are indented with line two or later by
extra four spaces
Package: toxinpred2
Toxinpred2.0IntroductionToxinPred2.0 is developed for predicting, mapping and scanning toxic proteins. More information on ToxinPred2.0 is available from its web serverhttp://webs.iiitd.edu.in/raghava/toxinpred2. This page provide information about standalone version of ToxinPred2.0.InstallationTo install the package, type the following command:pip install toxinpred2Minimum USAGETo know about the available option for the package, type the following command:toxinpred2.py -hTo run the example, type the following command:toxinpred2.py -i peptide.faFull Usage:Following is complete list of all options, you may get these options by "toxinpred2.py -h" 

usage: toxinpred2.py [-h] -i INPUT [-o OUTPUT] [-t THRESHOLD] [-m {1,2}] [-d {1,2}]Please provide following arguments

optional arguments:
  -h, --help            show this help message and exit
  -i INPUT, --input INPUT
                        Input: protein or peptide sequence in FASTA format or
                        single sequence per line in single letter code
  -o OUTPUT, --output OUTPUT
                        Output: File for saving results by default outfile.csv
  -t THRESHOLD, --threshold THRESHOLD
                        Threshold: Value between 0 to 1 by default 0.6
  -m {1,2}, -- model Model
                        Model: 1: AAC based RF, 2: Hybrid, by default 1
  -d {1,2}, --display {1,2}
                        Display: 1:Toxin peptide, 2: All peptides, by
                        default 1Input File: It allow users to provide input in two format; i) FASTA format (standard) (e.g. peptide.fa) and ii) Simple Format. In case of simple format, file should have one peptide sequence in a single line in single letter code (eg. peptide.seq).Output File: Program will save result in CSV format, in case user do not provide output file name, it will be stored in outfile.csv.Threshold: User should provide threshold between 0 and 1, please note score is proportional to toxic potential of peptide.Models: In this program, two models have been incorporated;  i) Model1 for predicting given input peptide/protein sequence as toxic and non-toxic peptide/proteins using Random Forest based on amino-acid composition of the peptide/proteins;ii) Model2 for predicting given input peptide/protein sequence as toxic and non-toxic peptide/proteins using Hybrid approach, which is the ensemble of Random Forest+ BLAST+ MERCI. It combines the scores generated from machine learning (RF), MERCI, and BLAST as Hybrid Score, and the prediction is based on Hybrid Score.
Package: toxinpred3
Toxinpred3.0A method for predicting toxicity of the peptidesIntroductionToxinPred3.0 is developed for predicting, mapping and scanning toxic/non-toxic peptides. It uses only composition based features for predicting toxic/non-toxic peptides.The final model also deploys a motif-based module which has been implemented using MERCI. More information on ToxinPred3.0 is available from its web serverhttp://webs.iiitd.edu.in/raghava/toxinpred3. Please read/cite the content about toxinpred3 for complete information including algorithm behind the approach.InstallationTo install the package, type the following command:pip install toxinpred3Minimum USAGETo know about the available option for the standalone, type the following command:toxinpred3.py -hTo run the example, type the following command:toxinpred3.py -i peptide.faFull Usage:Following is complete list of all options, you may get these options
usage: toxinpred3.py [-h] 
                     [-i INPUT]
                     [-o OUTPUT]
                     [-t THRESHOLD]
                     [-m {1,2}] 
                     [-d {1,2}]Please provide following arguments

optional arguments:
  -h, --help            show this help message and exit
  -i INPUT, --input INPUT
                        Input: protein or peptide sequence in FASTA format or
                        single sequence per line in single letter code
  -o OUTPUT, --output OUTPUT
                        Output: File for saving results by default outfile.csv
  -t THRESHOLD, --threshold THRESHOLD
                        Threshold: Value between 0 to 1 by default 0.38
  -m {1,2}, -- model Model
                        Model: 1: ML model, 2: Hybrid model, by default 2
  -d {1,2}, --display {1,2}
                        Display: 1:Toxin peptide, 2: All peptides, by
                        default 1Input File: It allow users to provide input in two format; i) FASTA format (standard) (e.g. peptide.fa) and ii) Simple Format. In case of simple format, file should have one peptide sequence in a single line in single letter code (eg. peptide.seq).Output File: Program will save result in CSV format, in case user do not provide output file name, it will be stored in outfile.csv.Threshold: User should provide threshold between 0 and 1, please note score is proportional to toxic potential of peptide.Models:  In this program, two models have been incorporated;  i) Model1 for predicting given input peptide sequence as toxic and non-toxic peptide using Extra tree based on amino-acid composition (AAC) and di peptide composition (DPC) of the peptide;ii) Model2 for predicting given input peptide sequence as toxic and non-toxic peptide using Hybrid approach, which is the ensemble of Extra tree + MERCI. It combines the scores generated from machine learning (ET), and MERCI as Hybrid Score, and the prediction is based on Hybrid Score.
Package: tox-ipdb-plugin
tox-ipdb-pluginTox plugin which installs ipdb in tox environments.
This is useful for local development, if you don’t want to modify the tox.ini.AcknowledgementThanks to sinoroc for the idea athttps://stackoverflow.com/a/60265699/2440346.ChangeLogReleases0.3 (2023-02-02)0.2 (2022-10-13)0.1 (2020-02-26)0.3 (2023-02-02)Update for tox v4.0.2 (2022-10-13)Fix interaction with provision tox.Use github actions.Update project setup.0.1 (2020-02-26)Initial version.
Package: tox-local-hooks
With this plugin, local tox hook implementations can be defined in a filetoxhooks.py, which is in the same folder as the tox configuration file.This will make it easier to write your own custom local hooks for tox. You just have to write the hooks intoxhooks.py(instead of creating a plugin package starting withtox-and then installing it in the same location as tox).Exampletox.inifile[tox]minversion=3.8.0requires=tox-local-hooksskipsdist=true[testenv]whitelist_externals=bashrandpwdenv=TESTPASSWORDcommands=bash-c'echo RANDOM PASSWORD: $TESTPASSWORD'Then create thetoxhooks.pyfile in the same folder astox-inifileimportpluggy,string,randomhookimpl=pluggy.HookimplMarker("tox")@hookimpldeftox_addoption(parser):parser.add_testenv_attribute("randpwdenv",type="string",help="Random password environmental variable")@hookimpl(tryfirst=True)deftox_configure(config):forenvConfinconfig.envconfigs.values():ifenvConf.randpwdenv:pwd=''.join(random.choice(string.ascii_letters)for_inrange(10))envConf.setenv[envConf.randpwdenv]=pwdWhile runningtox, you should be able to see the following outputRANDOM PASSWORD: {some_random_string}