Summary: Classes Without Boilerplate

*attrs* is the Python package that will bring back the **joy** of **writing classes** by relieving you from the drudgery of implementing object protocols (aka [dunder methods](https://www.attrs.org/en/latest/glossary.html#term-dunder-methods)).
Trusted by NASA for [Mars missions since 2020](https://github.com/readme/featured/nasa-ingenuity-helicopter)!

Its main goal is to help you to write **concise** and **correct** software without slowing down your code.

## Sponsors

*attrs* would not be possible without our [amazing sponsors](https://github.com/sponsors/hynek).
Especially those generously supporting us at the *The Organization* tier and higher:

<img title="FilePreviews" src="https://www.attrs.org/en/26.1.0/_static/sponsors/F


Summary: Universal Command Line Environment for AWS.

aws-cli
=======

.. image:: https://github.com/aws/aws-cli/actions/workflows/run-tests.yml/badge.svg
   :target: https://github.com/aws/aws-cli/actions/workflows/run-tests.yml
   :alt: Build Status

This package provides a unified command line interface to Amazon Web
Services.

Jump to:

-  `Getting Started <#getting-started>`__
-  `Getting Help <#getting-help>`__
-  `More Resources <#more-resources>`__

Entering Maintenance Mode on July 15, 2026
------------------------------------------

We `announced <https://aws.amazon.com/blogs/developer/cli-v1-maintenance-mode-announcement/>`__
the upcoming **end-of-support for the AWS CLI v1**. We recommend
that you migrate to
`AWS CLI v2 <https://docs.aws.amazon.com/cli/latest/userguide/cliv2-migration.html>`__.
For dates, additional details, and information on how to migrate,
please refer to the linked announcement.

Getting Started
---------------

This README is for the AWS CLI version 1. If you are looking for
information about the AWS CLI version 2, please visit the `v2
branch <https://github.com/aws/aws-cli/tree/v2>`__.

Requirements
~~~~~~~~~~~~

The aws-cli package works on Python versions:

-  3.10.x and greater
-  3.11.x and greater
-  3.12.x and greater
-  3.13.x and greater
-  3.14.x and greater

Notices
~~~~~~~

On 2026-04-29, support for Python 3.9 ended for the AWS CLI. This follows the
Python Software Foundation `end of support <https://peps.python.org/pep-0596/#lifespan>`__
for the runtime which occurred on 2025-10-31.
For more information, see this `blog post <https://aws.amazon.com/blogs/developer/python-support-policy-updates-for-aws-sdks-and-tools/>`__.

*Attention!*

*We recommend that all customers regularly monitor the* `Amazon Web
Services Security Bulletins
website <https://aws.amazon.com/security/security-bulletins>`__ *for
any important security bulletins related to aws-cli.*

Maintenance and Support for CLI Major Versions
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

The AWS CLI version 1 was

Development Status :: 5 - Production/Stable

Intended Audience :: System Administrators

License :: OSI Approved :: Apache Software License

Programming Language :: Python :: 3 :: Only


Summary: A database migration tool for SQLAlchemy.

Alembic is a database migrations tool written by the author
of `SQLAlchemy <http://www.sqlalchemy.org>`_.  A migrations tool
offers the following functionality:

* Can emit ALTER statements to a database in order to change
  the structure of tables and other constructs
* Provides a system whereby "migration scripts" may be constructed;
  each script indicates a particular series of steps that can "upgrade" a
  target database to a new version, and optionally a series of steps that can
  "downgrade" similarly, doing the same steps in reverse.
* Allows the scripts to execute in some sequential manner.

The goals of Alembic are:

* Very open ended and transparent configuration and operation.   A new
  Alembic environment is generated from a set of templates which is selected
  among a set of options when setup first occurs. The templates then deposit a
  series of scripts that define fully how database connectivity is established
  and how migration scripts are invoked; the migration scripts themselves are
  generated from a template within that series of scripts. The scripts can
  then be further customized to define exactly how databases will be
  interacted with and what structure new migration files should take.
* Full support for transactional DDL.   The default scripts ensure that all
  migrations occur within a transaction - for those databases which support
  this (Postgresql, Microsoft SQL Server), migrations can be tested with no
  need to manually undo changes upon failure.
* Minimalist script construction.  Basic operations like renaming
  tables/columns, adding/removing columns, changing column attributes can be
  performed through one line commands like alter_column(), rename_table(),
  add_constraint(). There is no need to recreate full SQLAlchemy Table
  structures for simple operations like these - the functions themselves
  generate minimalist schema structures behind the scenes to achieve the given
  DDL sequence.
* "auto generation" of migrations. W

Programming Language :: Python :: Implementation :: CPython

Programming Language :: Python :: Implementation :: PyPy


Summary: An abstract syntax tree for Python with inference support.

Astroid
=======

.. image:: https://codecov.io/gh/pylint-dev/astroid/branch/main/graph/badge.svg
    :target: https://codecov.io/gh/pylint-dev/astroid
    :alt: Coverage badge from codecov

.. image:: https://readthedocs.org/projects/astroid/badge/?version=latest
    :target: http://astroid.readthedocs.io/en/latest/?badge=latest
    :alt: Documentation Status

.. image:: https://img.shields.io/badge/code%20style-black-000000.svg
    :target: https://github.com/ambv/black

.. image:: https://results.pre-commit.ci/badge/github/pylint-dev/astroid/main.svg
   :target: https://results.pre-commit.ci/latest/github/pylint-dev/astroid/main
   :alt: pre-commit.ci status

.. |tidelift_logo| image:: https://raw.githubusercontent.com/pylint-dev/astroid/main/doc/media/Tidelift_Logos_RGB_Tidelift_Shorthand_On-White.png
   :width: 200
   :alt: Tidelift

.. list-table::
   :widths: 10 100

   * - |tidelift_logo|
     - Professional support for astroid is available as part of the
       `Tidelift Subscription`_.  Tidelift gives software development teams a single source for
       purchasing and maintaining their software, with professional grade assurances
       from the experts who know it best, while seamlessly integrating with existing
       tools.

.. _Tidelift Subscription: https://tidelift.com/subscription/pkg/pypi-astroid?utm_source=pypi-astroid&utm_medium=referral&utm_campaign=readme

What's this?
------------

The aim of this module is to provide a common base representation of
python source code. It is currently the library powering pylint's capabilities.

It provides a compatible representation which comes from the `_ast`
module.  It rebuilds the tree generated by the builtin _ast module by
recursively walking down the AST and building an extended ast. The new
node classes have additional methods and attributes for different
usages. They include some support for static inference and local name
scopes. Furthermore, astroid can also build partial trees by inspecting liv

typing-extensions>=4; python_version < "3.11"

Topic :: Software Development :: Libraries :: Python Modules

Topic :: Software Development :: Quality Assurance

Topic :: Software Development :: Testing

abstract syntax tree, python, static code analysis


Summary: In-process task scheduler with Cron-like capabilities

.. image:: https://github.com/agronholm/apscheduler/workflows/Python%20codeqa/test/badge.svg?branch=3.x
  :target: https://github.com/agronholm/apscheduler/actions?query=workflow%3A%22Python+codeqa%2Ftest%22+branch%3A3.x
  :alt: Build Status
.. image:: https://coveralls.io/repos/github/agronholm/apscheduler/badge.svg?branch=3.x
  :target: https://coveralls.io/github/agronholm/apscheduler?branch=3.x
  :alt: Code Coverage
.. image:: https://readthedocs.org/projects/apscheduler/badge/?version=3.x
  :target: https://apscheduler.readthedocs.io/en/master/?badge=3.x
  :alt: Documentation

Advanced Python Scheduler (APScheduler) is a Python library that lets you schedule your Python code
to be executed later, either just once or periodically. You can add new jobs or remove old ones on
the fly as you please. If you store your jobs in a database, they will also survive scheduler
restarts and maintain their state. When the scheduler is restarted, it will then run all the jobs
it should have run while it was offline [#f1]_.

Among other things, APScheduler can be used as a cross-platform, application specific replacement
to platform specific schedulers, such as the cron daemon or the Windows task scheduler. Please
note, however, that APScheduler is **not** a daemon or service itself, nor does it come with any
command line tools. It is primarily meant to be run inside existing applications. That said,
APScheduler does provide some building blocks for you to build a scheduler service or to run a
dedicated scheduler process.

APScheduler has three built-in scheduling systems you can use:

* Cron-style scheduling (with optional start/end times)
* Interval-based execution (runs jobs on even intervals, with optional start/end times)
* One-off delayed execution (runs jobs once, on a set date/time)

You can mix and match scheduling systems and the backends where the jobs are stored any way you
like. Supported backends for storing jobs include:

* Memory
* `SQLAlchemy <http://www.sqlalc

backports.zoneinfo; python_version < "3.9"

APScheduler[etcd,mongodb,redis,rethinkdb,sqlalchemy,tornado,zookeeper]; extra == "test"

PySide6; platform_python_implementation == "CPython" and extra == "test"

gevent; python_version < "3.14" and extra == "test"

twisted; python_version < "3.14" and extra == "test"


Summary: Placeholder for the old Airflow package

# Old Airflow package

Please install Airflow using `pip install apache-airflow` instead of `pip install airflow`.


Summary: Accelerate

Run your *raw* PyTorch training script on any kind of device

    <img src="https://raw.githubusercontent.com/huggingface/acc

swanlab[dashboard]; extra == "test-trackers"

Topic :: Scientific/Engineering :: Artificial Intelligence


Summary: Argon2 for Python

# *argon2-cffi*: Argon2 for Python

[Argon2](https://github.com/p-h-c/phc-winner-argon2) won the [Password Hashing Competition](https://www.password-hashing.net/) and *argon2-cffi* is the simplest way to use it in Python:

```pycon
>>> from argon2 import PasswordHasher
>>> ph = PasswordHasher()
>>> hash = ph.hash("correct horse battery staple")
>>> hash  # doctest: +SKIP
'$argon2id$v=19$m=65536,t=3,p=4$MIIRqgvgQbgj220jfp0MPA$YfwJSVjtjSU0zzV/P3S9nnQ/USre2wvJMjfCIjrTQbg'
>>> ph.verify(hash, "correct horse battery staple")
True
>>> ph.check_needs_rehash(hash)
False
>>> ph.verify(hash, "Tr0ub4dor&3")
Traceback (most recent call last):
  ...
argon2.exceptions.VerifyMismatchError: The password does not match the supplied hash

```
<!-- end short -->

## Project Links

- [**PyPI**](https://pypi.org/project/argon2-cffi/)
- [**GitHub**](https://github.com/hynek/argon2-cffi)
- [**Documentation**](https://argon2-cffi.readthedocs.io/)
- [**Changelog**](https://github.com/hynek/argon2-cffi/blob/main/CHANGELOG.md)
- [**Funding**](https://hynek.me/say-thanks/)
- The low-level Argon2 CFFI bindings are maintained in the separate [*argon2-cffi-bindings*](https://github.com/hynek/argon2-cffi-bindings) project.

## Release Information

### Added

- Official support for Python 3.13 and 3.14.
  No code changes were necessary.

### Removed

- Python 3.7 is not supported anymore.
  [#186](https://github.com/hynek/argon2-cffi/pull/186)

### Changed

- `argon2.PasswordHasher.check_needs_rehash()` now also accepts bytes like the rest of the API.
  [#174](https://github.com/hynek/argon2-cffi/pull/174)

- Improved parameter compatibility handling for Pyodide / WebAssembly environments.
  [#190](https://github.com/hynek/argon2-cffi/pull/190)

---

[Full Changelog →](https://github.com/hynek/argon2-cffi/blob/main/CHANGELOG.md)

## Credits

*argon2-cffi* is maintained by [Hynek Schlawack](https://hynek.me/).

The development is kindly supported by my employer [Variomedia AG](https://www.vario

Operating System :: Microsoft :: Windows


Summary: The AWS SDK for Python

===============================
Boto3 - The AWS SDK for Python
===============================

|Version| |Python| |License|

Boto3 is the Amazon Web Services (AWS) Software Development Kit (SDK) for
Python, which allows Python developers to write software that makes use
of services like Amazon S3 and Amazon EC2. You can find the latest, most
up to date, documentation at our `doc site`_, including a list of
services that are supported.

Boto3 is maintained and published by `Amazon Web Services`_.

Boto (pronounced boh-toh) was named after the fresh water dolphin native to the Amazon river. The name was chosen by the author of the original Boto library, Mitch Garnaat, as a reference to the company.

Notices
-------

On 2026-04-29, support for Python 3.9 ended for Boto3. This follows the
Python Software Foundation `end of support <https://peps.python.org/pep-0596/#lifespan>`__
for the runtime which occurred on 2025-10-31.

For more information on deprecations, see this
`blog post <https://aws.amazon.com/blogs/developer/python-support-policy-updates-for-aws-sdks-and-tools/>`__.

.. _boto: https://docs.pythonboto.org/
.. _`doc site`: https://docs.aws.amazon.com/boto3/latest/
.. _`Amazon Web Services`: https://aws.amazon.com/what-is-aws/
.. |Python| image:: https://img.shields.io/pypi/pyversions/boto3.svg?style=flat
    :target: https://pypi.python.org/pypi/boto3/
    :alt: Python Versions
.. |Version| image:: https://img.shields.io/pypi/v/boto3.svg?style=flat
    :target: https://pypi.python.org/pypi/boto3/
    :alt: Package Version
.. |License| image:: https://img.shields.io/pypi/l/boto3.svg?style=flat
    :target: https://github.com/boto/boto3/blob/develop/LICENSE
    :alt: License

Getting Started
---------------
Assuming that you have a supported version of Python installed, you can first
set up your environment with:

.. code-block:: sh

    $ python -m venv .venv
    ...
    $ . .venv/bin/activate

Then, you can install boto3 from PyPI with:

.. code-block:: sh

Programming Language :: Python :: Free Threading :: 2 - Beta


Summary: Low-level, data-driven core of boto 3.

botocore
========

|Version| |Python| |License|

A low-level interface to a growing number of Amazon Web Services. The
botocore package is the foundation for the
`AWS CLI <https://github.com/aws/aws-cli>`__ as well as
`boto3 <https://github.com/boto/boto3>`__.

Botocore is maintained and published by `Amazon Web Services`_.

Notices
-------

On 2026-04-29, support for Python 3.9 ended for Botocore. This follows the
Python Software Foundation `end of support <https://peps.python.org/pep-0596/#lifespan>`__
for the runtime which occurred on 2025-10-31.

For more information, see this `blog post <https://aws.amazon.com/blogs/developer/python-support-policy-updates-for-aws-sdks-and-tools/>`__.

.. _`Amazon Web Services`: https://aws.amazon.com/what-is-aws/
.. |Python| image:: https://img.shields.io/pypi/pyversions/botocore.svg?style=flat
    :target: https://pypi.python.org/pypi/botocore/
    :alt: Python Versions
.. |Version| image:: http://img.shields.io/pypi/v/botocore.svg?style=flat
    :target: https://pypi.python.org/pypi/botocore/
    :alt: Package Version
.. |License| image:: http://img.shields.io/pypi/l/botocore.svg?style=flat
    :target: https://github.com/boto/botocore/blob/develop/LICENSE.txt
    :alt: License

Getting Started
---------------
Assuming that you have Python and ``virtualenv`` installed, set up your environment and install the required dependencies like this or you can install the library using ``pip``:

.. code-block:: sh

    $ git clone https://github.com/boto/botocore.git
    $ cd botocore
    $ python -m venv .venv
    ...
    $ source .venv/bin/activate
    $ python -m pip install -r requirements.txt
    $ python -m pip install -e .

.. code-block:: sh

    $ pip install botocore

Using Botocore
~~~~~~~~~~~~~~
After installing botocore

Next, set up credentials (in e.g. ``~/.aws/credentials``):

.. code-block:: ini

    [default]
    aws_access_key_id = YOUR_KEY
    aws_secret_access_key = YOUR_SECRET

Then, set up a default region (in e.


Summary: Screen-scraping library

Beautiful Soup is a library that makes it easy to scrape information
from web pages. It sits atop an HTML or XML parser, providing Pythonic
idioms for iterating, searching, and modifying the parse tree.

# Quick start

```
>>> from bs4 import BeautifulSoup
>>> soup = BeautifulSoup("<p>Some<b>bad<i>HTML")
>>> print(soup.prettify())
<html>
 <body>
  <p>
   Some
   <b>
    bad
    <i>
     HTML
    </i>
   </b>
  </p>
 </body>
</html>
>>> soup.find(string="bad")
'bad'
>>> soup.i
<i>HTML</i>
#
>>> soup = BeautifulSoup("<tag1>Some<tag2/>bad<tag3>XML", "xml")
#
>>> print(soup.prettify())
<?xml version="1.0" encoding="utf-8"?>
<tag1>
 Some
 <tag2/>
 bad
 <tag3>
  XML
 </tag3>
</tag1>
```

To go beyond the basics, [comprehensive documentation is available](https://www.crummy.com/software/BeautifulSoup/bs4/doc/).

# Links

* [Homepage](https://www.crummy.com/software/BeautifulSoup/bs4/)
* [Documentation](https://www.crummy.com/software/BeautifulSoup/bs4/doc/)
* [Discussion group](https://groups.google.com/group/beautifulsoup/)
* [Development](https://code.launchpad.net/beautifulsoup/)
* [Bug tracker](https://bugs.launchpad.net/beautifulsoup/)
* [Complete changelog](https://git.launchpad.net/beautifulsoup/tree/CHANGELOG)

# Note on Python 2 sunsetting

Beautiful Soup's support for Python 2 was discontinued on December 31,
2020: one year after the sunset date for Python 2 itself. From this
point onward, new Beautiful Soup development will exclusively target
Python 3. The final release of Beautiful Soup 4 to support Python 2
was 4.9.3.

# Supporting the project

If you use Beautiful Soup as part of your professional work, please consider a
[Tidelift subscription](https://tidelift.com/subscription/pkg/pypi-beautifulsoup4?utm_source=pypi-beautifulsoup4&utm_medium=referral&utm_campaign=readme).
This will support many of the free software projects your organization
depends on, not just Beautiful Soup.

If you use Beautiful Soup for personal projects, the best way to say
thank you i

charset-normalizer; extra == "charset-normalizer"

Topic :: Text Processing :: Markup :: HTML

Topic :: Text Processing :: Markup :: SGML

Topic :: Text Processing :: Markup :: XML


Summary: The uncompromising code formatter.

[![Black Logo](https://raw.githubusercontent.com/psf/black/main/docs/_static/logo2-readme.png)](https://black.readthedocs.io/en/stable/)

The Uncompromising Code Formatter

> “Any color you like.”

_Black_ is the uncompromising Python code formatter. By using it, you agree to cede
control over minutiae of hand-formatting. In return, _Black_ gives you speed,
determinism, and freedom from `pycodestyle` nagging about formatting. You will save time
and mental energy for more important matters.

Blackened code looks the same regardless of the project you're reading. Formatting
becomes transparent after a while and you can focus on the content instead.

_Black_ makes

typing-extensions>=4.0.1; python_version < "3.11"

uvloop>=0.15.2; sys_platform != "win32" and extra == "uvloop"

winloop>=0.5.0; sys_platform == "win32" and extra == "uvloop"

automation, autopep8, formatter, gofmt, pyfmt, rustfmt, yapf


Summary: Security oriented static analyser for python code.

.. image:: https://raw.githubusercontent.com/pycqa/bandit/main/logo/logotype-sm.png
    :alt: Bandit

======

.. image:: https://github.com/PyCQA/bandit/actions/workflows/pythonpackage.yml/badge.svg?branch=main
    :target: https://github.com/PyCQA/bandit/actions?query=workflow%3A%22Build+and+Test+Bandit%22+branch%3Amain
    :alt: Build Status

.. image:: https://readthedocs.org/projects/bandit/badge/?version=latest
    :target: https://readthedocs.org/projects/bandit/
    :alt: Docs Status

.. image:: https://img.shields.io/pypi/v/bandit.svg
    :target: https://pypi.org/project/bandit/
    :alt: Latest Version

.. image:: https://img.shields.io/pypi/pyversions/bandit.svg
    :target: https://pypi.org/project/bandit/
    :alt: Python Versions

.. image:: https://img.shields.io/pypi/format/bandit.svg
    :target: https://pypi.org/project/bandit/
    :alt: Format

.. image:: https://img.shields.io/badge/license-Apache%202-blue.svg
    :target: https://github.com/PyCQA/bandit/blob/main/LICENSE
    :alt: License

.. image:: https://img.shields.io/discord/825463413634891776.svg
    :target: https://discord.gg/qYxpadCgkx
    :alt: Discord

A security linter from PyCQA

* Free software: Apache license
* Documentation: https://bandit.readthedocs.io/en/latest/
* Source: https://github.com/PyCQA/bandit
* Bugs: https://github.com/PyCQA/bandit/issues
* Contributing: https://github.com/PyCQA/bandit/blob/main/CONTRIBUTING.md

Overview
--------

Bandit is a tool designed to find common security issues in Python code. To do
this Bandit processes each file, builds an AST from it, and runs appropriate
plugins against the AST nodes. Once Bandit has finished scanning all the files
it generates a report.

Bandit was originally developed within the OpenStack Security Project and
later rehomed to PyCQA.

.. image:: https://raw.githubusercontent.com/pycqa/bandit/main/bandit-terminal.png
    :alt: Bandit Example Screen Shot

Show Your Style
---------------

.. image:: https://img.shields.i

colorama>=0.3.9; platform_system == "Windows"

tomli>=1.1.0; python_version < "3.11" and extra == "toml"

jschema-to-python>=1.2.3; extra == "sarif"

Intended Audience :: Information Technology


Summary: Modern password hashing for your software and your servers

bcrypt
======

.. image:: https://img.shields.io/pypi/v/bcrypt.svg
    :target: https://pypi.org/project/bcrypt/
    :alt: Latest Version

.. image:: https://github.com/pyca/bcrypt/workflows/CI/badge.svg?branch=main
    :target: https://github.com/pyca/bcrypt/actions?query=workflow%3ACI+branch%3Amain

Acceptable password hashing for your software and your servers (but you should
really use argon2id or scrypt)

Installation
============

To install bcrypt, simply:

.. code:: console

    $ pip install bcrypt

Note that bcrypt should build very easily on Linux provided you have a C
compiler and a Rust compiler (the minimum supported Rust version is 1.56.0).

For Debian and Ubuntu, the following command will ensure that the required dependencies are installed:

.. code:: console

    $ sudo apt-get install build-essential cargo

For Fedora and RHEL-derivatives, the following command will ensure that the required dependencies are installed:

.. code:: console

    $ sudo yum install gcc cargo

For Alpine, the following command will ensure that the required dependencies are installed:

.. code:: console

    $ apk add --update musl-dev gcc cargo

Alternatives
============

While bcrypt remains an acceptable choice for password storage, depending on your specific use case you may also want to consider using scrypt (either via `standard library`_ or `cryptography`_) or argon2id via `argon2_cffi`_.

Changelog
=========

5.0.0
-----

* Bumped MSRV to 1.74.
* Added support for Python 3.14 and free-threaded Python 3.14.
* Added support for Windows on ARM.
* Passing ``hashpw`` a password longer than 72 bytes now raises a
  ``ValueError``. Previously the password was silently truncated, following the
  behavior of the original OpenBSD ``bcrypt`` implementation.

4.3.0
-----

* Dropped support for Python 3.7.
* We now support free-threaded Python 3.13.
* We now support PyPy 3.11.
* We now publish wheels for free-threaded Python 3.13, for PyPy 3.11 on
  ``manylinux``, and for AR

The Python Cryptographic Authority developers <cryptography-dev@python.org>

pytest!=3.3.0,>=3.2.1; extra == "tests"
mypy; extra == "typecheck"

Programming Language :: Python :: Free Threading :: 3 - Stable


Summary: Fast and simple WSGI-framework for small web-applications.

Topic :: Internet :: WWW/HTTP :: Dynamic Content :: CGI Tools/Libraries

Topic :: Internet :: WWW/HTTP :: HTTP Servers

Topic :: Internet :: WWW/HTTP :: WSGI :: Application

Topic :: Internet :: WWW/HTTP :: WSGI :: Middleware

Topic :: Internet :: WWW/HTTP :: WSGI :: Server

Topic :: Software Development :: Libraries :: Application Frameworks


Summary: behave is behaviour-driven development, Python style

======
behave
======

.. |badge.latest_version| image:: https://img.shields.io/pypi/v/behave.svg
    :target: https://pypi.python.org/pypi/behave
    :alt: Latest Version

.. |badge.license| image:: https://img.shields.io/pypi/l/behave.svg
    :target: https://pypi.python.org/pypi/behave/
    :alt: License

.. |badge.CI_status| image:: https://github.com/behave/behave/actions/workflows/test.yml/badge.svg
    :target: https://github.com/behave/behave/actions/workflows/test.yml
    :alt: CI Build Status

.. |badge.docs_status| image:: https://readthedocs.org/projects/behave/badge/?version=latest
    :target: https://behave.readthedocs.io/en/latest/?badge=latest
    :alt: Documentation Status

.. |badge.discussions| image:: https://img.shields.io/badge/chat-github_discussions-darkgreen
   :target: https://github.com/behave/behave/discussions
   :alt: Discussions at https://github.com/behave/behave/discussions

.. |badge.gitter| image:: https://badges.gitter.im/join_chat.svg
   :target: https://app.gitter.im/#/room/#behave_behave:gitter.im
   :alt: Chat at https://gitter.im/behave/behave

.. |badge.gurubase| image:: https://img.shields.io/badge/Gurubase-Ask%20behave%20Guru-006BFF
   :target: https://gurubase.io/g/behave
   :alt: Ask behave Guru at https://gurubase.io/g/behave

.. |logo| image:: https://raw.github.com/behave/behave/master/docs/_static/behave_logo1.png

|badge.latest_version| |badge.license| |badge.CI_status| |badge.docs_status| |badge.discussions| |badge.gitter| |badge.gurubase|

behave is behavior-driven development, Python style.

|logo|

Behavior-driven development (or BDD) is an agile software development
technique that encourages collaboration between developers, QA and
non-technical or business participants in a software project.

*behave* uses tests written in a natural language style, backed up by Python
code.

First, `install *behave*.`_

Now make a directory called "features/".
In that directory create a file called "example.feature" containi

Jens Engel <jenisys@noreply.github.com>, Peter Bittner <bittner@noreply.github.com>

cucumber-expressions>=17.1.0; python_version >= "3.8"

win_unicode_console; python_version <= "3.9"

tomli>=1.1.0; python_version >= "3.0" and python_version < "3.11"

pytest<5.0,>=4.2; python_version < "3.0" and extra == "develop"

pytest>=5.0; python_version >= "3.0" and extra == "develop"

pytest-html<2.0,>=1.19.0; python_version < "3.0" and extra == "develop"

pytest-html>=2.0; python_version >= "3.0" and extra == "develop"

mock<4.0; python_version < "3.6" and extra == "develop"

mock>=4.0; python_version >= "3.6" and extra == "develop"

PyHamcrest>=2.0.2; python_version >= "3.0" and extra == "develop"

PyHamcrest<2.0; python_version < "3.0" and extra == "develop"

virtualenv>=20.26.6; python_version >= "3.7" and extra == "develop"

virtualenv<20.22.0; python_version < "3.7" and extra == "develop"

invoke<2.0,>=1.7.0; python_version < "3.6" and extra == "develop"

invoke>=1.7.0; python_version >= "3.6" and extra == "develop"

path>=13.1.0; python_version >= "3.5" and extra == "develop"

path.py>=11.5.0; python_version < "3.5" and extra == "develop"

ruff; python_version >= "3.7" and extra == "develop"

sphinx>=7.4.0; python_version >= "3.7" and extra == "docs"

sphinx<4.4,>=1.6; python_version < "3.7" and extra == "docs"

furo>=2024.04.27; python_version >= "3.8" and extra == "docs"

sphinxcontrib-applehelp>=1.0.8; python_version >= "3.7" and extra == "docs"

sphinxcontrib-htmlhelp>=2.0.5; python_version >= "3.7" and extra == "docs"

sphinx-copybutton>=0.5.2; python_version >= "3.7" and extra == "docs"

behave-html-formatter>=0.9.10; python_version >= "3.6" and extra == "formatters"

behave-html-pretty-formatter>=1.9.1; python_version >= "3.6" and extra == "formatters"

pytest<5.0; python_version < "3.0" and extra == "testing"

pytest>=5.0; python_version >= "3.0" and extra == "testing"

pytest-html<2.0,>=1.19.0; python_version < "3.0" and extra == "testing"

pytest-html>=2.0; python_version >= "3.0" and extra == "testing"

mock<4.0; python_version < "3.6" and extra == "testing"

mock>=4.0; python_version >= "3.6" and extra == "testing"

PyHamcrest>=2.0.2; python_version >= "3.0" and extra == "testing"

PyHamcrest<2.0; python_version < "3.0" and extra == "testing"

path>=13.1.0; python_version >= "3.5" and extra == "testing"

path.py<13.0,>=11.5.0; python_version < "3.5" and extra == "testing"

freezegun>=1.5.1; python_version > "3.7" and extra == "testing"

Development Status :: 5 - Production/Stable

Programming Language :: Python :: Implementation :: CPython

Programming Language :: Python :: Implementation :: Jython

Programming Language :: Python :: Implementation :: PyPy

Topic :: Software Development :: Testing

BDD, behavior-driven-development, bdd-framework, behave, gherkin, cucumber-like


Summary: A simple, correct Python build frontend

# build

[![pre-commit.ci status](https://results.pre-commit.ci/badge/github/pypa/build/main.svg)](https://results.pre-commit.ci/latest/github/pypa/build/main)
[![CI test](https://github.com/pypa/build/actions/workflows/test.yml/badge.svg)](https://github.com/pypa/build/actions/workflows/test.yml)
[![codecov](https://codecov.io/gh/pypa/build/branch/main/graph/badge.svg)](https://codecov.io/gh/pypa/build)

[![Documentation Status](https://readthedocs.org/projects/pypa-build/badge/?version=latest)](https://build.pypa.io/en/latest/?badge=latest)
[![PyPI version](https://badge.fury.io/py/build.svg)](https://pypi.org/project/build/)
[![Discord](https://img.shields.io/discord/803025117553754132?label=Discord%20chat%20%23build)](https://discord.gg/pypa)

A simple, correct Python build frontend.

See the [documentation](https://build.pypa.io) for more information.

### Installation

`build` can be installed via `pip` or an equivalent via:

```console
$ pip install build
```

### Usage

```console
$ python -m build
```

This will build the package in an isolated environment, generating a
source-distribution and wheel in the directory `dist/`. See the
[documentation](https://build.pypa.io) for full information. Build is also
available via the command line as `pyproject-build` once installed.

### Common arguments

- `--sdist` (`-s`): Produce just an SDist
- `--wheel` (`-w`): Produce just a wheel
- `--metadata`: Produce just the metadata as JSON. Cannot be used with `--sdist`/`--wheel`.
- `-C<option>=<value>`: A Config-setting, the PEP 517 way of passing options to a backend. Can be passed multiple times. Matching options will make a list. Note that setuptools has very limited support.
- `--config-json=<value>`: An alternative way to pass in complex config settings as JSON strings. Can't be used with `-C`.
- `--installer`: Pick an installer for the isolated build (`pip` or `uv`).
- `--no-isolation` (`-n`): Disable build isolation.
- `--skip-dependency-check` (`-x`): Disable de

Filipe Laíns <lains@riseup.net>, Bernát Gábor <gaborjbernat@gmail.com>, layday <layday@protonmail.com>, Henry Schreiner <henryschreineriii@gmail.com>

importlib-metadata>=4.6; python_full_version < "3.10.2"

virtualenv>=20.17; extra == "virtualenv" and (python_version >= "3.10" and python_version < "3.14")

virtualenv>=20.31; extra == "virtualenv" and python_version >= "3.14"

Programming Language :: Python :: 3 :: Only


Summary: Interactive plots and applications in the browser from Python

<picture>
  <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/bokeh/pm/main/assets/logos/SVG/bokeh-logo-white-text-no-padding.svg">

</picture>

----

[Bokeh](https://bokeh.org) is an interactive visualization library for modern web browsers. It provides elegant, concise construction of versatile graphics and affords high-performance interactivity across large or streaming datasets. Bokeh can help anyone who wants to create interactive plots, dashboards, and data applications quickly and easily.

  Package

  Project

</

tornado>=6.2; sys_platform != "emscripten"

Intended Audience :: Financial and Insurance Industry

Intended Audience :: Healthcare Industry

Topic :: Scientific/Engineering :: Information Analysis

Topic :: Scientific/Engineering :: Mathematics

Topic :: Scientific/Engineering :: Visualization


Summary: DNS toolkit

# dnspython

[![Build Status](https://github.com/rthalley/dnspython/actions/workflows/ci.yml/badge.svg)](https://github.com/rthalley/dnspython/actions/)
[![Documentation Status](https://readthedocs.org/projects/dnspython/badge/?version=latest)](https://dnspython.readthedocs.io/en/latest/?badge=latest)
[![PyPI version](https://badge.fury.io/py/dnspython.svg)](https://badge.fury.io/py/dnspython)
[![License: ISC](https://img.shields.io/badge/License-ISC-brightgreen.svg)](https://opensource.org/licenses/ISC)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

## INTRODUCTION

`dnspython` is a DNS toolkit for Python. It supports almost all record types. It
can be used for queries, zone transfers, and dynamic updates. It supports
TSIG-authenticated messages and EDNS0.

`dnspython` provides both high- and low-level access to DNS. The high-level
classes perform queries for data of a given name, type, and class, and return an
answer set. The low-level classes allow direct manipulation of DNS zones,
messages, names, and records.

To see a few of the ways `dnspython` can be used, look in the `examples/`
directory.

`dnspython` is a utility to work with DNS, `/etc/hosts` is thus not used. For
simple forward DNS lookups, it's better to use `socket.getaddrinfo()` or
`socket.gethostbyname()`.

`dnspython` originated at Nominum where it was developed to facilitate the
testing of DNS software.

## ABOUT THIS RELEASE

This is of `dnspython` 2.8.0.
Please read
[What's New](https://dnspython.readthedocs.io/en/stable/whatsnew.html) for
information about the changes in this release.

## INSTALLATION

* Many distributions have dnspython packaged for you, so you should check there
  first.
* To use a wheel downloaded from PyPi, run:

```
    pip install dnspython
```

* To install from the source code, go into the top-level of the source code
  and run:

```
    pip install --upgrade pip build
    python -m build
    pip install

wmi>=1.5.1; platform_system == "Windows" and extra == "wmi"

Intended Audience :: System Administrators

License :: OSI Approved :: ISC License (ISCL)

Operating System :: Microsoft :: Windows

Topic :: Software Development :: Libraries :: Python Modules


Summary: Persistent/Functional/Immutable data structures

Pyrsistent
==========
.. image:: https://github.com/tobgu/pyrsistent/actions/workflows/tests.yaml/badge.svg
    :target: https://github.com/tobgu/pyrsistent/actions/workflows/tests.yaml

.. _Pyrthon: https://www.github.com/tobgu/pyrthon
.. _Pyrsistent_extras: https://github.com/mingmingrr/pyrsistent-extras

Pyrsistent is a number of persistent collections (by some referred to as functional data structures). Persistent in
the sense that they are immutable.

All methods on a data structure that would normally mutate it instead return a new copy of the structure containing the
requested updates. The original structure is left untouched.

This will simplify the reasoning about what a program does since no hidden side effects ever can take place to these
data structures. You can rest assured that the object you hold a reference to will remain the same throughout its
lifetime and need not worry that somewhere five stack levels below you in the darkest corner of your application
someone has decided to remove that element that you expected to be there.

Pyrsistent is influenced by persistent data structures such as those found in the standard library of Clojure. The
data structures are designed to share common elements through path copying.
It aims at taking these concepts and make them as pythonic as possible so that they can be easily integrated into any python
program without hassle.

If you want use literal syntax to define them in your code rather
than function calls check out Pyrthon_. Be aware, that one is experimental, unmaintained and alpha software.

If you cannot find the persistent data structure you're looking for here you may want to take a look at
Pyrsistent_extras_ which is maintained by @mingmingrr. If you still don't find what you're looking for please
open an issue for discussion. If we agree that functionality is missing you may want to go ahead and create
a Pull Request implement the missing functionality.

Examples
--------
.. _Sequence: collections_


Summary: Python extension for computing string edit distances and similarities.

# Levenshtein

## Introduction
The Levenshtein Python C extension module contains functions for fast
computation of:

* Levenshtein (edit) distance, and edit operations
* string similarity
* approximate median strings, and generally string averaging
* string sequence and set similarity

> :warning: The package was renamed to `Levenshtein` and can be found [here](https://github.com/rapidfuzz/Levenshtein).
  The `python-Levenshtein` package will continue to be updated alongside the new package

## Requirements
* Python 3.9 or later

## Installation
```bash
pip install levenshtein
```

## Documentation

The documentation for the current version can be found at [https://rapidfuzz.github.io/Levenshtein/](https://rapidfuzz.github.io/Levenshtein/)

## Support the project

If you are using Levenshtein for your work and feel like giving a bit of your own benefit back to support the project, consider sending us money through GitHub Sponsors or PayPal that we can use to buy us free time for the maintenance of this great library, to fix bugs in the software, review and integrate code contributions, to improve its f

Programming Language :: Python :: 3
Programming Language :: Python :: 3.10
Programming Language :: Python :: 3.11
Programming Language :: Python :: 3.12
Programming Language :: Python :: 3.13
Programming Language :: Python :: 3.14

string, Levenshtein, comparison, edit-distance


Summary: Portable network interface information.

netifaces 0.10.8
================

+-------------+------------------+
| Linux/macOS | |BuildStatus|    |
+-------------+------------------+
| Windows     | |WinBuildStatus| |
+-------------+------------------+

.. |BuildStatus| image:: https://travis-ci.org/al45tair/netifaces.svg?branch=master
   :target: https://travis-ci.org/al45tair/netifaces
   :alt: Build Status (Linux/Mac)

.. |WinBuildStatus| image:: https://ci.appveyor.com/api/projects/status/3ctn1bl0aigpfjoo/branch/master?svg=true
   :target: https://ci.appveyor.com/project/al45tair/netifaces/branch/master
   :alt: Build Status (Windows)

.. warning::

   netifaces needs a new maintainer.  al45tair is no longer able to maintain it
   or make new releases due to work commitments.

1. What is this?
----------------

It's been annoying me for some time that there's no easy way to get the
address(es) of the machine's network interfaces from Python.  There is
a good reason for this difficulty, which is that it is virtually impossible
to do so in a portable manner.  However, it seems to me that there should
be a package you can easy_install that will take care of working out the
details of doing so on the machine you're using, then you can get on with
writing Python code without concerning yourself with the nitty gritty of
system-dependent low-level networking APIs.

This package attempts to solve that problem.

2. How do I use it?
-------------------

First you need to install it, which you can do by typing::

  tar xvzf netifaces-0.10.8.tar.gz
  cd netifaces-0.10.8
  python setup.py install

**Note that you will need the relevant developer tools for your platform**,
as netifaces is written in C and installing this way will compile the extension.

Once that's done, you'll need to start Python and do something like the
following::

>>> import netifaces

Then if you enter

>>> netifaces.interfaces()
['lo0', 'gif0', 'stf0', 'en0', 'en1', 'fw0']

you'll see the list of interface identifiers for your machine.

You ca

Development Status :: 4 - Beta
Intended Audience :: Developers
License :: OSI Approved :: MIT License
Programming Language :: Python
Programming Language :: Python :: 2
Programming Language :: Python :: 2.7
Programming Language :: Python :: 3
Programming Language :: Python :: 3.4
Programming Language :: Python :: 3.5
Programming Language :: Python :: 3.6
Programming Language :: Python :: 3.7
Programming Language :: Python :: 3.8
Topic :: System :: Networking


pytest!=3.3.0,>=3.2.1; extra == "tests"
mypy; extra == "typecheck"

Development Status :: 5 - Production/Stable

License :: OSI Approved :: Apache Software License

Programming Language :: Python :: Free Threading :: 3 - Stable

Programming Language :: Python :: Implementation :: CPython

Programming Language :: Python :: Implementation :: PyPy


Summary: SSH2 protocol library

|version| |python| |license| |ci| |coverage|

.. |version| image:: https://img.shields.io/pypi/v/paramiko
    :target: https://pypi.org/project/paramiko/
    :alt: PyPI - Package Version
.. |python| image:: https://img.shields.io/pypi/pyversions/paramiko
    :target: https://pypi.org/project/paramiko/
    :alt: PyPI - Python Version
.. |license| image:: https://img.shields.io/pypi/l/paramiko
    :target: https://github.com/paramiko/paramiko/blob/main/LICENSE
    :alt: PyPI - License
.. |ci| image:: https://img.shields.io/circleci/build/github/paramiko/paramiko/main
    :target: https://app.circleci.com/pipelines/github/paramiko/paramiko
    :alt: CircleCI
.. |coverage| image:: https://img.shields.io/codecov/c/gh/paramiko/paramiko
    :target: https://app.codecov.io/gh/paramiko/paramiko
    :alt: Codecov

Welcome to Paramiko!
====================

Paramiko is a pure-Python [#]_ implementation of the SSHv2 protocol [#]_,
providing both client and server functionality. It provides the foundation for
the high-level SSH library `Fabric <https://fabfile.org>`_, which is what we
recommend you use for common client use-cases such as running remote shell
commands or transferring files.

Direct use of Paramiko itself is only intended for users who need
advanced/low-level primitives or want to run an in-Python sshd.

For installation information, changelogs, FAQs and similar, please visit `our
main project website <https://paramiko.org>`_; for API details, see `the
versioned docs <https://docs.paramiko.org>`_. Additionally, the project
maintainer keeps a `roadmap <http://bitprophet.org/projects#roadmap>`_ on his
personal site.

.. [#]
    Paramiko relies on `cryptography <https://cryptography.io>`_ for crypto
    functionality, which makes use of C and Rust extensions but has many
    precompiled options available. See `our installation page
    <https://www.paramiko.org/installing.html>`_ for details.

.. [#]
    OpenSSH's RFC specification page is a fantastic resource and co

Programming Language :: Python :: 3 :: Only


Summary: ECDSA cryptographic signature library (pure python)

# Pure-Python ECDSA and ECDH

[![GitHub CI](https://github.com/tlsfuzzer/python-ecdsa/actions/workflows/ci.yml/badge.svg)](https://github.com/tlsfuzzer/python-ecdsa/actions/workflows/ci.yml)
[![Documentation Status](https://readthedocs.org/projects/ecdsa/badge/?version=latest)](https://ecdsa.readthedocs.io/en/latest/?badge=latest)
[![Coverage Status](https://coveralls.io/repos/github/tlsfuzzer/python-ecdsa/badge.svg?branch=master)](https://coveralls.io/github/tlsfuzzer/python-ecdsa?branch=master)
![condition coverage](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/tomato42/9b6ca1f3410207fbeca785a178781651/raw/python-ecdsa-condition-coverage.json)
![mutation score](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/tomato42/9b6ca1f3410207fbeca785a178781651/raw/python-ecdsa-mutation-score.json)
[![CodeQL](https://github.com/tlsfuzzer/python-ecdsa/actions/workflows/codeql.yml/badge.svg)](https://github.com/tlsfuzzer/python-ecdsa/actions/workflows/codeql.yml)
[![Latest Version](https://img.shields.io/pypi/v/ecdsa.svg?style=flat)](https://pypi.python.org/pypi/ecdsa/)
![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg?style=flat)

This is an easy-to-use implementation of ECC (Elliptic Curve Cryptography)
with support for ECDSA (Elliptic Curve Digital Signature Algorithm),
EdDSA (Edwards-curve Digital Signature Algorithm) and ECDH
(Elliptic Curve Diffie-Hellman), implemented purely in Python, released under
the MIT license. With this library, you can quickly create key pairs (signing
key and verifying key), sign messages, and verify the signatures. You can
also agree on a shared secret key based on exchanged public keys.
The keys and signatures are very short, making them easy to handle and
incorporate into other protocols.

**NOTE: This library should not be used in production settings, see [Security](#Security) for more details.**

## Features

This library provides key generation, signing, verifyi

six>=1.9.0
gmpy; extra == "gmpy"
gmpy2; extra == "gmpy2"

Programming Language :: Python
Programming Language :: Python :: 2
Programming Language :: Python :: 2.6
Programming Language :: Python :: 2.7
Programming Language :: Python :: 3
Programming Language :: Python :: 3.10
Programming Language :: Python :: 3.11
Programming Language :: Python :: 3.12
Programming Language :: Python :: 3.13
Programming Language :: Python :: 3.6
Programming Language :: Python :: 3.7
Programming Language :: Python :: 3.8
Programming Language :: Python :: 3.9


Summary: Pure-Python implementation of ASN.1 types and DER/BER/CER codecs (X.208)

ASN.1 library for Python
------------------------
[![PyPI](https://img.shields.io/pypi/v/pyasn1.svg?maxAge=2592000)](https://pypi.org/project/pyasn1)
[![Python Versions](https://img.shields.io/pypi/pyversions/pyasn1.svg)](https://pypi.org/project/pyasn1/)
[![Build status](https://github.com/pyasn1/pyasn1/actions/workflows/main.yml/badge.svg)](https://github.com/pyasn1/pyasn1/actions/workflows/main.yml)
[![Coverage Status](https://img.shields.io/codecov/c/github/pyasn1/pyasn1.svg)](https://codecov.io/github/pyasn1/pyasn1)
[![GitHub license](https://img.shields.io/badge/license-BSD-blue.svg)](https://raw.githubusercontent.com/pyasn1/pyasn1/master/LICENSE.txt)

This is a free and open source implementation of ASN.1 types and codecs
as a Python package. It has been first written to support particular
protocol (SNMP) but then generalized to be suitable for a wide range
of protocols based on
[ASN.1 specification](https://www.itu.int/rec/dologin_pub.asp?lang=e&id=T-REC-X.208-198811-W!!PDF-E&type=items).

**NOTE:** The package is now maintained by *Christian Heimes* and
*Simon Pichugin* in project https://github.com/pyasn1/pyasn1.

Features
--------

* Generic implementation of ASN.1 types (X.208)
* Standards compliant BER/CER/DER codecs
* Can operate on streams of serialized data
* Dumps/loads ASN.1 structures from Python types
* 100% Python, works with Python 3.8+
* MT-safe
* Contributed ASN.1 compiler [Asn1ate](https://github.com/kimgr/asn1ate)

Why using pyasn1
----------------

ASN.1 solves the data serialisation problem. This solution was
designed long ago by the wise Ancients. Back then, they did not
have the luxury of wasting bits. That is why ASN.1 is designed
to serialise data structures of unbounded complexity into
something compact and efficient when it comes to processing
the data.

That probably explains why many network protocols and file formats
still rely on the 30+ years old technology. Including a number of
high-profile Internet protocols and file format

Intended Audience :: Information Technology

Intended Audience :: Telecommunications Industry


# Internationalized Domain Names in Applications (IDNA)

Support for [Internationalized Domain Names in Applications
(IDNA)](https://tools.ietf.org/html/rfc5891) and [Unicode IDNA
Compatibility Processing](https://unicode.org/reports/tr46/). It
supersedes the standard library's `encodings.idna`, which only
implements the 2003 specification, offering broader script coverage and
limiting domains with known security vulnerabilities.

## Usage

Package may be installed from [PyPI](https://pypi.org/project/idna/) via
the typical methods (e.g. `python3 -m pip install idna`)

For typical usage, the `encode` and `decode` functions will take a
domain name argument and perform a conversion to ASCII-compatible encoding
(known as A-labels), or to Unicode strings (known as U-labels)
respectively.

```pycon
>>> import idna
>>> idna.encode('ドメイン.テスト')
b'xn--eckwd4c7c.xn--zckzah'
>>> print(idna.decode('xn--eckwd4c7c.xn--zckzah'))
ドメイン.テスト
```

Conversions can be applied at a per-label basis using the `ulabel` or
`alabel` functions for specialized use cases.

### Compatibility Mapping (UTS #46)

This library provides support for [Unicode IDNA Compatibility
Processing](https://unicode.org/reports/tr46/) which normalizes input from
different potential ways a user may input a domain prior to performing the IDNA
conversion operations. This functionality, known as a
[mapping](https://tools.ietf.org/html/rfc5895), is considered by the
specification to be a local user-interface issue distinct from IDNA
conversion functionality.

For example, "Königsgäßchen" is not a permissible label as capital letters
are not allowed. UTS 46 will convert this into lower case prior to applying
the IDNA conversion.

```pycon
>>> import idna
>>> idna.encode('Königsgäßchen')
...
idna.core.InvalidCodepoint: Codepoint U+004B at position 1 of 'Königsgäßchen' not allowed
>>> idna.encode('Königsgäßchen', uts46=True)
b'xn--knigsgchen-b4a3dun'
>>> idna.decode('xn--knigsgchen-b4a3dun')
'königsgäßchen'
```

When perf

ruff>=0.6.2; extra == "all"
mypy>=1.11.2; extra == "all"
pytest>=8.3.2; extra == "all"


Summary: The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet.

Charset Detection, for Everyone 👋

  The Real First Universal Charset Detector

  Featured Packages

  In other language (unofficial port - by the community)

> A library that helps you read text from an unknown charset encoding.
 Motivated by `chardet`,
> I'm trying to resolve the issue by taking a new approach.
> All IANA character set names for which the Python core library provides codecs are supported.
> You can also register your own set of codecs, and yes, it would work as-is.

This project offers you an alternative to **Universal Charset Encoding Detector**, also known as **Chardet**.

| Feature                                          | [Chardet](https://github.com/chardet/chardet) |                                       Charset Normalizer                                        | [cChardet](https://github.com/PyYoshi/cChardet) |
|--------------------------------------------------|:------

"Ahmed R. TAHRI" <tahri.ahmed@proton.me>

Programming Language :: Python :: Free Threading :: 4 - Resilient

encoding, charset, charset-detector, detector, normalization, unicode, chardet, detect


Summary: The Plone Content Management System

  Plone

[![PyPI - Wheel](https://img.shields.io/pypi/wheel/plone)](https://pypi.org/project/plone/)
[![PyPI - License](https://img.shields.io/pypi/l/plone)](https://pypi.org/project/plone/)
[![PyPI - Status](https://img.shields.io/pypi/status/plone)](https://pypi.org/project/plone/)

[![GitHub contributors](https://img.shields.io/github/contributors/plone/Products.CMFPlone)](https://github.com/plone/Products.CMFPlone)
![GitHub Repo stars](https://img.shields.io/github/stars/plone/Plone?style=flat-square)

Plone is a mature, secure, and user-friendly content management system (CMS).

Plone was first released to the public on October 4, 2001.

Plone has the maturity, stability, and reliability of an application maintained by open source developers with decades of experience, while continually evolving and adapting to modern technology.

Lots of customizations can be made trough-the-web, such as creating content types, themes, workflows, and much more.
Plone may be extended and used as a framework on which to build custom CMS-like solutions.

Plone works as a

- Full-featured server-side rendered HTML CMS.
- React-based frontend for editing and viewing content, backed by a server with a REST API.
- Headless CMS server with a REST API, allowing a developer to build a custom frontend with their chosen technology.

  Installing Plone

Plone is available on Linux, Microsoft Windows, macOS, and BSD platforms.

Plone may be run as a container in the cloud with Docker and other Open Containers Initiative compliant platforms.
[Example Dockerfiles](https://6.docs.plone.org/install/containers/images/index.html) and base images are available.

[Install Plone by choosing an option from plone.org](https://plone.org/download)

  Documentation

License :: OSI Approved :: GNU General Public License v2 (GPLv2)

Topic :: Internet :: WWW/HTTP :: Dynamic Content


Summary: Desktop client for Tryton

tryton
======

The desktop client of Tryton.
Tryton is business software, ideal for companies of any size, easy to use,
complete and 100% Open Source.
It provides modularity, scalability and security.

Tiny SPRL, Lorenzo Gil Sanchez, Udo Spallek, virtual things - Preisler & Spallek GbR, B2CK SRL, Rodrigo Hübner, Antoine Smolders, SALUC SA

Bertrand Chenal <bertrand.chenal@b2ck.com>, Cédric Krier <cedric.krier@b2ck.com>, Nicolas Évrard <nicolas.evrard@b2ck.com>, Maxime Richez <maxime.richez@saluc.com>

pycairo
pygobject>=3.19
python-dateutil
goocalendar>=0.7; extra == "calendar"
playsound3; extra == "sound"


Summary: Source of truth and network automation platform.

# Nautobot

![Nautobot](https://raw.githubusercontent.com/nautobot/nautobot/develop/nautobot/docs/nautobot_logo.svg "Nautobot logo")

Nautobot is a Network Source of Truth and Network Automation Platform built as a web application atop the [Django](https://www.djangoproject.com/) Python framework with a
[PostgreSQL](https://www.postgresql.org/) or [MySQL](https://www.mysql.com) database.

## Key Use Cases

**1. Flexible Source of Truth for Networking** - Nautobot core data models are used to define the intended state of network infrastructure enabling it as a Source of Truth. While a baseline set of models are provided (such as IP networks and addresses, devices and racks, circuits and cable, etc.) it is Nautobot's goal to offer maximum data model flexibility. This is enabled through features such as user-defined relationships, custom fields on any model, and data validation that permits users to codify everything from naming standards to having automated tests run before data can be populated into Nautobot.

**2. Extensible Data Platform for Automation** - Nautobot has a rich feature set to seamlessly integrate with network automation solutions. Nautobot offers GraphQL and native Git integration along with REST APIs and webhooks. Git integration dynamically loads YAML data files as Nautobot config contexts. Nautobot also has an evolving plugin system that enables users to create custom models, APIs, and UI elements. The plugin system is also used to unify and aggregate disparate data sources creating a Single Source of Truth to streamline data management for network automation.

**3. Platform for Network Automation Apps** - The Nautobot plugin system enables users to create Network Automation Apps. Apps can be as lightweight or robust as needed based on user needs. Using Nautobot for creating custom applications saves up to 70% development time by re-using features such as authentication, permissions, webhooks, GraphQL, change logging, etc. all while having access

django-auth-ldap<5.4,>=5.3.0; extra == "all"

django-auth-ldap<5.4,>=5.3.0; extra == "ldap"

django-storages<1.15,>=1.14.6; extra == "all"

django-storages<1.15,>=1.14.6; extra == "remote-storage"

mysqlclient<2.3,>=2.2.8; extra == "mysql"

social-auth-core[saml]<4.10,>=4.9.1; extra == "all"

social-auth-core[saml]<4.10,>=4.9.1; extra == "sso"


Summary: Automated Malware Analysis System

.. image:: https://cuckoosandbox.org/assets/images/cuckoo-black.png
   :alt: Cuckoo Sandbox
   :target: https://cuckoosandbox.org/

`Cuckoo Sandbox <https://cuckoosandbox.org/>`_ is the leading open source
automated malware analysis system.

What does that mean? It simply means that you can throw any suspicious file at
it and in a matter of seconds Cuckoo will provide you back some detailed
results outlining what such file did when executed inside an isolated
environment.

If you want to contribute to development, report a bug, make a feature request
or ask a question, please first take a look at our `community guidelines`_.
For development, please also take a look at the `contribution requirements`_.
Make sure you check our existing Issues and Pull Requests and that you join
our `IRC or Slack channel <https://cuckoosandbox.org/discussion>`_.

For setup instructions, please refer
`to <https://cuckoo.sh/docs/installation/host/requirements.html>`_
`our <https://cuckoo.sh/docs/installation/host/installation.html>`_
`documentation <https://cuckoo.sh/docs/index.html>`_.

This is a development version, we do not recommend its use in production; the
latest stable version may be installed through :code:`pip install -U cuckoo`.

You can find the full documentation of the latest stable release
`here <https://cuckoo.sh/docs>`_.

.. image:: https://travis-ci.org/cuckoosandbox/cuckoo.png?branch=master
   :alt: Linux Build Status
   :target: https://travis-ci.org/cuckoosandbox/cuckoo

.. image:: https://ci.appveyor.com/api/projects/status/p892esebjdbhq653/branch/master?svg=true
   :alt: Windows Build Status
   :target: https://ci.appveyor.com/project/jbremer/cuckoo/branch/master

.. image:: https://coveralls.io/repos/github/cuckoosandbox/cuckoo/badge.svg?branch=master
   :alt: Coverage Coverage Status
   :target: https://coveralls.io/github/cuckoosandbox/cuckoo?branch=master

.. image:: https://codecov.io/gh/cuckoosandbox/cuckoo/branch/master/graph/badge.svg
   :alt: Codecov Cove

License :: OSI Approved :: GNU General Public License v3 (GPLv3)

cuckoo sandbox automated malware analysis project threat intelligence cert soc


Summary: ChartPress: render and publish helm charts and images

# [chartpress](https://github.com/jupyterhub/chartpress)

[![Latest PyPI version](https://img.shields.io/pypi/v/chartpress?logo=pypi)](https://pypi.python.org/pypi/chartpress)
[![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/jupyterhub/chartpress/test.yaml?logo=github)](https://github.com/jupyterhub/chartpress/actions)
[![GitHub](https://img.shields.io/badge/issue_tracking-github-blue?logo=github)](https://github.com/jupyterhub/chartpress/issues)
[![Discourse](https://img.shields.io/badge/help_forum-discourse-blue?logo=discourse)](https://discourse.jupyter.org/c/jupyterhub)
[![Gitter](https://img.shields.io/badge/social_chat-gitter-blue?logo=gitter)](https://gitter.im/jupyterhub/jupyterhub)

Chartpress automate basic Helm chart development work. It is tightly used in development of the [JupyterHub](https://github.com/jupyterhub/zero-to-jupyterhub-k8s) and [BinderHub](https://github.com/jupyterhub/binderhub) Helm charts.

## Features

Chartpress can do the following with the help of some configuration.

- Update Chart.yaml's version appropriately
- Build docker images and tag them appropriately
- Push built images to a docker image repository
- Update values.yaml to reference the built images
- Publish a chart to a Helm chart registry based on GitHub pages
- Reset changes to Chart.yaml and values.yaml

Jupyter Development Team <jupyter@googlegroups.com>

ruamel.yaml>=0.15.44
docker!=5.0.0,>=3.2.0
gitpython; extra == "test"
pytest; extra == "test"
pytest-cov; extra == "test"
tbump; extra == "test"

Intended Audience :: System Administrators


Summary: Superset has moved to apache-superset, as of 0.34.0 onwards, please pip install apache-superset

Superset has moved to `apache-superset`, as of `0.34.0` onwards, please `pip install apache-superset`

Programming Language :: Python :: 3.6
Programming Language :: Python :: 3.7


Summary: OCR/HTR engine for all the languages

Description
===========

.. image:: https://github.com/mittagessen/kraken/actions/workflows/test.yml/badge.svg
    :target: https://github.com/mittagessen/kraken/actions/workflows/test.yml

kraken is a turn-key OCR system optimized for historical and non-Latin script
material.

kraken's main features are:

  - Fully trainable layout analysis, reading order, and character recognition
  - `Right-to-Left <https://en.wikipedia.org/wiki/Right-to-left>`_, `BiDi
    <https://en.wikipedia.org/wiki/Bi-directional_text>`_, and Top-to-Bottom
    script support
  - `ALTO <https://www.loc.gov/standards/alto/>`_, PageXML, abbyyXML, and hOCR
    output
  - Word bounding boxes and character cuts
  - Multi-script recognition support
  - `Public repository <https://zenodo.org/communities/ocr_models>`_ of model files
  - Variable recognition network architecture

Installation
============

Kraken can be run on Linux or Mac OS X (both x64 and ARM). Installation is
through the on-board *pip* utility. To not pollute the global state of your
distribution's package manager it is recommended to use virtual environments.
If you do not have a setup or do not wish to handle virtual environments
yourself you can use `pipx`.

.. code-block:: console

   $ sudo apt install pipx
   $ pipx install kraken

kraken works both on Linux and Mac OS X and with any python interpreter between
3.10 and 3.13. It is possible the installation fails because `pipx` defaults to
an unsupported interpreter version. In that case you need to install a
compatible interpreter version such as 3.11 and then specify this version
explicitly:

.. code-block:: console

   $ sudo apt install python3.13-full
   $ pipx install --python python3.13 kraken

Installation using pip
----------------------

Create and activate a separate virtual environment using whatever tool you
like.

.. code-block:: console

  $ pip install kraken

or by running pip in the git repository:

.. code-block:: console

  $ pip install .

If you want di

sphinx-autodoc-typehints; extra == "docs"

sphinx-github-changelog; extra == "docs"

Topic :: Scientific/Engineering :: Artificial Intelligence

Topic :: Scientific/Engineering :: Image Recognition


Summary: Extensions to the standard Python datetime module

dateutil - powerful extensions to datetime
==========================================

|pypi| |support| |licence|

|gitter| |readthedocs|

|travis| |appveyor| |pipelines| |coverage|

.. |pypi| image:: https://img.shields.io/pypi/v/python-dateutil.svg?style=flat-square
    :target: https://pypi.org/project/python-dateutil/
    :alt: pypi version

.. |support| image:: https://img.shields.io/pypi/pyversions/python-dateutil.svg?style=flat-square
    :target: https://pypi.org/project/python-dateutil/
    :alt: supported Python version

.. |travis| image:: https://img.shields.io/travis/dateutil/dateutil/master.svg?style=flat-square&label=Travis%20Build
    :target: https://travis-ci.org/dateutil/dateutil
    :alt: travis build status

.. |appveyor| image:: https://img.shields.io/appveyor/ci/dateutil/dateutil/master.svg?style=flat-square&logo=appveyor
    :target: https://ci.appveyor.com/project/dateutil/dateutil
    :alt: appveyor build status

.. |pipelines| image:: https://dev.azure.com/pythondateutilazure/dateutil/_apis/build/status/dateutil.dateutil?branchName=master
    :target: https://dev.azure.com/pythondateutilazure/dateutil/_build/latest?definitionId=1&branchName=master
    :alt: azure pipelines build status

.. |coverage| image:: https://codecov.io/gh/dateutil/dateutil/branch/master/graphs/badge.svg?branch=master
    :target: https://codecov.io/gh/dateutil/dateutil?branch=master
    :alt: Code coverage

.. |gitter| image:: https://badges.gitter.im/dateutil/dateutil.svg
   :alt: Join the chat at https://gitter.im/dateutil/dateutil
   :target: https://gitter.im/dateutil/dateutil

.. |licence| image:: https://img.shields.io/pypi/l/python-dateutil.svg?style=flat-square
    :target: https://pypi.org/project/python-dateutil/
    :alt: licence

.. |readthedocs| image:: https://img.shields.io/readthedocs/dateutil/latest.svg?style=flat-square&label=Read%20the%20Docs
   :alt: Read the documentation at https://dateutil.readthedocs.io/en/latest/
   :target: https://dateuti

Development Status :: 5 - Production/Stable

License :: OSI Approved :: Apache Software License

Topic :: Software Development :: Libraries


Summary: Backported and Experimental Type Hints for Python 3.9+

# Typing Extensions

[![Chat at https://gitter.im/python/typing](https://badges.gitter.im/python/typing.svg)](https://gitter.im/python/typing)

[Documentation](https://typing-extensions.readthedocs.io/en/latest/#) –
[PyPI](https://pypi.org/project/typing-extensions/)

## Overview

The `typing_extensions` module serves two related purposes:

- Enable use of new type system features on older Python versions. For example,
  `typing.TypeGuard` is new in Python 3.10, but `typing_extensions` allows
  users on previous Python versions to use it too.
- Enable experimentation with new type system PEPs before they are accepted and
  added to the `typing` module.

`typing_extensions` is treated specially by static type checkers such as
mypy and pyright. Objects defined in `typing_extensions` are treated the same
way as equivalent forms in `typing`.

`typing_extensions` uses
[Semantic Versioning](https://semver.org/). The
major version will be incremented only for backwards-incompatible changes.
Therefore, it's safe to depend
on `typing_extensions` like this: `typing_extensions ~=x.y`,
where `x.y` is the first version that includes all features you need.
[This](https://packaging.python.org/en/latest/specifications/version-specifiers/#compatible-release)
is equivalent to `typing_extensions >=x.y, <(x+1)`. Do not depend on `~= x.y.z`
unless you really know what you're doing; that defeats the purpose of
semantic versioning.

## Included items

See [the documentation](https://typing-extensions.readthedocs.io/en/latest/#) for a
complete listing of module contents.

## Contributing

See [CONTRIBUTING.md](https://github.com/python/typing_extensions/blob/main/CONTRIBUTING.md)
for how to contribute to `typing_extensions`.

"Guido van Rossum, Jukka Lehtosalo, Łukasz Langa, Michael Lee" <levkivskyi@gmail.com>

annotations, backport, checker, checking, function, hinting, hints, type, typechecking, typehinting, typehints, typing


Summary: A module wrapper for os.path

.. image:: https://img.shields.io/pypi/v/path.svg
   :target: https://pypi.org/project/path

.. image:: https://img.shields.io/pypi/pyversions/path.svg

.. image:: https://github.com/jaraco/path/actions/workflows/main.yml/badge.svg
   :target: https://github.com/jaraco/path/actions?query=workflow%3A%22tests%22
   :alt: tests

.. image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json
    :target: https://github.com/astral-sh/ruff
    :alt: Ruff

.. image:: https://readthedocs.org/projects/path/badge/?version=latest
   :target: https://path.readthedocs.io/en/latest/?badge=latest

.. image:: https://img.shields.io/badge/skeleton-2025-informational
   :target: https://blog.jaraco.com/skeleton

.. image:: https://tidelift.com/badges/package/pypi/path
   :target: https://tidelift.com/subscription/pkg/pypi-path?utm_source=pypi-path&utm_medium=readme

``path`` (aka path pie, formerly ``path.py``) implements path
objects as first-class entities, allowing common operations on
files to be invoked on those path objects directly. For example:

.. code-block:: python

    from path import Path

    d = Path("/home/guido/bin")
    for f in d.files("*.py"):
        f.chmod(0o755)

    # Globbing
    for f in d.files("*.py"):
        f.chmod("u+rwx")

    # Changing the working directory:
    with Path("somewhere"):
        # cwd in now `somewhere`
        ...

    # Concatenate paths with /
    foo_txt = Path("bar") / "foo.txt"

Path pie is `hosted at Github <https://github.com/jaraco/path>`_.

Find `the documentation here <https://path.readthedocs.io>`_.

Guides and Testimonials
=======================

Yasoob wrote the Python 101 `Writing a Cleanup Script
<http://freepythontips.wordpress.com/2014/01/23/python-101-writing-a-cleanup-script/>`_
based on ``path``.

Advantages
==========

Path pie provides a superior experience to similar offerings.

Python 3.4 introduced
`pathlib <https://docs.python.org/3/library/pathl

pywin32; (platform_system == "Windows" and python_version < "3.12") and extra == "test"

pytest-ruff>=0.2.1; sys_platform != "cygwin" and extra == "check"

Topic :: Software Development :: Libraries :: Python Modules


Summary: library with cross-python path, ini-parsing, io, code, log facilities

.. image:: https://img.shields.io/pypi/v/py.svg
    :target: https://pypi.org/project/py

.. image:: https://img.shields.io/conda/vn/conda-forge/py.svg
    :target: https://anaconda.org/conda-forge/py

.. image:: https://img.shields.io/pypi/pyversions/py.svg
  :target: https://pypi.org/project/py

.. image:: https://github.com/pytest-dev/py/workflows/build/badge.svg
  :target: https://github.com/pytest-dev/py/actions

**NOTE**: this library is in **maintenance mode** and should not be used in new code.

The py lib is a Python development support library featuring
the following tools and modules:

* ``py.path``:  uniform local and svn path objects  -> please use pathlib/pathlib2 instead
* ``py.apipkg``:  explicit API control and lazy-importing -> please use the standalone package instead
* ``py.iniconfig``:  easy parsing of .ini files -> please use the standalone package instead
* ``py.code``: dynamic code generation and introspection (deprecated, moved to ``pytest`` as a implementation detail).

**NOTE**: prior to the 1.4 release this distribution used to
contain py.test which is now its own package, see https://docs.pytest.org

For questions and more information please visit https://py.readthedocs.io

Bugs and issues: https://github.com/pytest-dev/py

Authors: Holger Krekel and others, 2004-2017

holger krekel, Ronny Pfannschmidt, Benjamin Peterson and others

Operating System :: Microsoft :: Windows

Programming Language :: Python :: Implementation :: CPython

Programming Language :: Python :: Implementation :: PyPy

Topic :: Software Development :: Testing


Summary: Most extensible Python build backend with support for C/C++ extension modules

.. |pypi-version| image:: https://img.shields.io/pypi/v/setuptools.svg
   :target: https://pypi.org/project/setuptools

.. |py-version| image:: https://img.shields.io/pypi/pyversions/setuptools.svg

.. |test-badge| image:: https://github.com/pypa/setuptools/actions/workflows/main.yml/badge.svg
   :target: https://github.com/pypa/setuptools/actions?query=workflow%3A%22tests%22
   :alt: tests

.. |ruff-badge| image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json
   :target: https://github.com/astral-sh/ruff
   :alt: Ruff

.. |docs-badge| image:: https://img.shields.io/readthedocs/setuptools/latest.svg
   :target: https://setuptools.pypa.io

.. |skeleton-badge| image:: https://img.shields.io/badge/skeleton-2026-informational
   :target: https://blog.jaraco.com/skeleton

.. |codecov-badge| image:: https://img.shields.io/codecov/c/github/pypa/setuptools/master.svg?logo=codecov&logoColor=white
   :target: https://codecov.io/gh/pypa/setuptools

.. |tidelift-badge| image:: https://tidelift.com/badges/github/pypa/setuptools?style=flat
   :target: https://tidelift.com/subscription/pkg/pypi-setuptools?utm_source=pypi-setuptools&utm_medium=readme

.. |discord-badge| image:: https://img.shields.io/discord/803025117553754132
   :target: https://discord.com/channels/803025117553754132/815945031150993468
   :alt: Discord

|pypi-version| |py-version| |test-badge| |ruff-badge| |docs-badge| |skeleton-badge| |codecov-badge| |discord-badge|

See the `Quickstart <https://setuptools.pypa.io/en/latest/userguide/quickstart.html>`_
and the `User's Guide <https://setuptools.pypa.io/en/latest/userguide/>`_ for
instructions on how to use Setuptools.

Questions and comments should be directed to `GitHub Discussions
<https://github.com/pypa/setuptools/discussions>`_.
Bug reports and especially tested patches may be
submitted directly to the `bug tracker
<https://github.com/pypa/setuptools/issues>`_.

Code of Conduct
===========

Python Packaging Authority <distutils-sig@python.org>

build[virtualenv]>=1.0.3; extra == "test"

pytest-perf; sys_platform != "cygwin" and extra == "test"

jaraco.develop>=7.21; (python_version >= "3.9" and sys_platform != "cygwin") and extra == "test"

pygments-github-lexers==0.0.5; extra == "doc"

sphinx-notfound-page<2,>=1; extra == "doc"

importlib_metadata>=6; python_version < "3.10" and extra == "core"

tomli>=2.0.1; python_version < "3.11" and extra == "core"

pytest-checkdocs>=2.14; extra == "check"

ruff>=0.13.0; sys_platform != "cygwin" and extra == "check"

pytest-mypy>=1.0.1; platform_python_implementation != "PyPy" and extra == "type"

importlib_metadata>=7.0.2; python_version < "3.10" and extra == "type"

jaraco.develop>=7.21; sys_platform != "cygwin" and extra == "type"

Programming Language :: Python :: 3 :: Only

Topic :: System :: Archiving :: Packaging

Topic :: System :: Systems Administration

CPAN PyPI distutils eggs package management


Summary: The PyPA recommended tool for installing Python packages.

pip - The Python Package Installer
==================================

.. |pypi-version| image:: https://img.shields.io/pypi/v/pip.svg
   :target: https://pypi.org/project/pip/
   :alt: PyPI

.. |python-versions| image:: https://img.shields.io/pypi/pyversions/pip
   :target: https://pypi.org/project/pip
   :alt: PyPI - Python Version

.. |docs-badge| image:: https://readthedocs.org/projects/pip/badge/?version=latest
   :target: https://pip.pypa.io/en/latest
   :alt: Documentation

|pypi-version| |python-versions| |docs-badge|

Pip is the `package installer`_ for Python. You can use pip to install packages from the `Python Package Index`_ and other indexes.

Please take a look at our documentation for how to install and use pip:

* `Installation`_
* `Usage`_

We release updates regularly, with a new version every 3 months. Find more details in our documentation:

* `Release notes`_
* `Release process`_

If you find bugs, need help, or want to talk to the developers, please use our mailing lists or chat rooms:

* `Issue tracking`_
* `Discourse channel`_
* `User IRC`_

If you want to get involved, head over to GitHub to get the source code, look at our development documentation and feel free to jump on the developer mailing lists and chat rooms:

* `GitHub page`_
* `Development documentation`_
* `Development IRC`_

Code of Conduct
---------------

Everyone interacting in the pip project's codebases, issue trackers, chat
rooms, and mailing lists is expected to follow the `PSF Code of Conduct`_.

.. _package installer: https://packaging.python.org/guides/tool-recommendations/
.. _Python Package Index: https://pypi.org
.. _Installation: https://pip.pypa.io/en/stable/installation/
.. _Usage: https://pip.pypa.io/en/stable/
.. _Release notes: https://pip.pypa.io/en/stable/news.html
.. _Release process: https://pip.pypa.io/en/latest/development/release-process/
.. _GitHub page: https://github.com/pypa/pip
.. _Development documentation: https://pip.pypa.io/en/latest/developmen

The pip developers <distutils-sig@python.org>

Topic :: Software Development :: Build Tools


Summary: Python Distribution Utilities

UNKNOWN


Summary: Python command-line parsing library

The argparse module makes it easy to write user friendly command line
interfaces.

The program defines what arguments it requires, and argparse will figure out
how to parse those out of sys.argv. The argparse module also automatically
generates help and usage messages and issues errors when users give the
program invalid arguments.

As of Python >= 2.7 and >= 3.2, the argparse module is maintained within the
Python standard library. For users who still need to support Python < 2.7 or
< 3.2, it is also provided as a separate package, which tries to stay
compatible with the module in the standard library, but also supports older
Python versions.

Also, we can fix bugs here for users who are stuck on some non-current python
version, like e.g. 3.2.3 (which has bugs that were fixed in a later 3.2.x
release).

argparse is licensed under the Python license, for details see LICENSE.txt.

Compatibility
-------------

argparse should work on Python >= 2.3, it was tested on:

* 2.3, 2.4, 2.5, 2.6 and 2.7
* 3.1, 3.2, 3.3, 3.4

Installation
------------

Try one of these:

    python setup.py install

    easy_install argparse

    pip install argparse

    putting argparse.py in some directory listed in sys.path should also work

Bugs
----

If you find a bug in argparse (pypi), please try to reproduce it with latest
python 2.7 and 3.4 (and use argparse from stdlib).

If it happens there also, please file a bug in the python.org issue tracker.
If it does not happen there, file a bug in the argparse package issue tracker.

License :: OSI Approved :: Python Software Foundation License


Summary: WSGI (PEP 333) Reference Library

This is a standalone release of the ``wsgiref`` library, that provides
validation support for WSGI 1.0.1 (PEP 3333) for Python versions < 3.2,
and includes the new ``wsgiref.util.test()`` utility function.

For this version's documentation, see:

HTML
  http://peak.telecommunity.com/wsgiref_docs/

PDF
  http://peak.telecommunity.com/wsgiref.pdf

(You can also check out the `development version`_ using
``easy_install wsgiref==dev``.)

.. _development version: svn://svn.eby-sarna.com/svnroot/wsgiref#egg=wsgiref-dev


Summary: Pythonic argument parser, that will make you smile

``docopt`` creates *beautiful* command-line interfaces
======================================================================

Video introduction to **docopt**: `PyCon UK 2012: Create *beautiful*
command-line interfaces with Python <http://youtu.be/pXhcPJK5cMc>`_

    New in version 0.6.1:

    - Fix issue `#85 <https://github.com/docopt/docopt/issues/85>`_
      which caused improper handling of ``[options]`` shortcut
      if it was present several times.

    New in version 0.6.0:

    - New argument ``options_first``, disallows interspersing options
      and arguments.  If you supply ``options_first=True`` to
      ``docopt``, it will interpret all arguments as positional
      arguments after first positional argument.

    - If option with argument could be repeated, its default value
      will be interpreted as space-separated list. E.g. with
      ``[default: ./here ./there]`` will be interpreted as
      ``['./here', './there']``.

    Breaking changes:

    - Meaning of ``[options]`` shortcut slightly changed. Previously
      it ment *"any known option"*. Now it means *"any option not in
      usage-pattern"*.  This avoids the situation when an option is
      allowed to be repeated unintentionaly.

    - ``argv`` is ``None`` by default, not ``sys.argv[1:]``.
      This allows ``docopt`` to always use the *latest* ``sys.argv``,
      not ``sys.argv`` during import time.

Isn't it awesome how ``optparse`` and ``argparse`` generate help
messages based on your code?!

*Hell no!*  You know what's awesome?  It's when the option parser *is*
generated based on the beautiful help message that you write yourself!
This way you don't need to write this stupid repeatable parser-code,
and instead can write only the help message--*the way you want it*.

**docopt** helps you create most beautiful command-line interfaces
*easily*:

.. code:: python

    """Naval Fate.

    Usage:
      naval_fate.py ship new <name>...
      naval_fate.py ship <name> move <x> <y> [--spe

Development Status :: 3 - Alpha
License :: OSI Approved :: MIT License
Programming Language :: Python :: 2.5
Programming Language :: Python :: 2.6
Programming Language :: Python :: 2.7
Programming Language :: Python :: 3.2
Programming Language :: Python :: 3.3
Topic :: Utilities

option arguments parsing optparse argparse getopt


Summary: Fast and simple WSGI-framework for small web-applications.

Topic :: Internet :: WWW/HTTP :: Dynamic Content :: CGI Tools/Libraries

Topic :: Internet :: WWW/HTTP :: HTTP Servers

Topic :: Internet :: WWW/HTTP :: WSGI :: Application

Topic :: Internet :: WWW/HTTP :: WSGI :: Middleware

Topic :: Internet :: WWW/HTTP :: WSGI :: Server

Topic :: Software Development :: Libraries :: Application Frameworks


Summary: A Python interface to the UNIX dialog utility and mostly-compatible programs

===============================================================================
Python wrapper for the UNIX "dialog" utility
===============================================================================
Easy writing of graphical interfaces for terminal-based applications
-------------------------------------------------------------------------------

Overview
--------

pythondialog is a Python wrapper for the UNIX dialog_ utility
originally written by Savio Lam and later rewritten by Thomas E. Dickey.
Its purpose is to provide an easy to use, pythonic and as complete as
possible interface to dialog_ from Python code.

.. _dialog: https://invisible-island.net/dialog/dialog.html

pythondialog is free software, licensed under the GNU LGPL (GNU Lesser
General Public License). Its home page is located at:

  https://pythondialog.sourceforge.io/

and contains a `short example`_, screenshots_, a `summary of the recent
changes`_, links to the `documentation`_, the `Git repository`_, the
`mailing list`_, the `issue tracker`_, etc.

.. _short example:  https://pythondialog.sourceforge.io/#example
.. _screenshots:    https://pythondialog.sourceforge.io/gallery.html
.. _summary of the recent changes:
                    https://pythondialog.sourceforge.io/news.html
.. _documentation:  https://pythondialog.sourceforge.io/doc/
.. _Git repository: https://sourceforge.net/p/pythondialog/code/
.. _mailing list:   https://sourceforge.net/p/pythondialog/mailman/
.. _issue tracker:  https://sourceforge.net/p/pythondialog/_list/tickets

If you want to get a quick idea of what this module allows one to do,
you can download a release tarball and run ``demo.py``::

  PYTHONPATH=. python3 examples/demo.py

What is pythondialog good for? What are its limitations?
--------------------------------------------------------

As you might infer from the name, dialog is a high-level program that
generates dialog boxes. So is pythondialog. They allow you to build nice
interfaces quickly and easil

Development Status :: 5 - Production/Stable

License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL)

Topic :: Software Development :: Libraries :: Python Modules

Topic :: Software Development :: User Interfaces

Topic :: Software Development :: Widget Sets


Summary: Hamcrest framework for matcher objects

PyHamcrest
==========

| |docs| |status| |version| |downloads|

.. |docs| image:: https://readthedocs.org/projects/pyhamcrest/badge/?version=latest
    :target: https://pyhamcrest.readthedocs.io/en/latest/?badge=latest
    :alt: Documentation Status

.. |status| image:: https://github.com/hamcrest/PyHamcrest/workflows/CI/badge.svg
    :alt: CI Build Status
    :target: https://github.com/hamcrest/PyHamcrest/actions?query=workflow%3ACI

.. |version| image:: http://img.shields.io/pypi/v/PyHamcrest.svg?style=flat
    :alt: PyPI Package latest release
    :target: https://pypi.python.org/pypi/PyHamcrest

.. |downloads| image:: http://img.shields.io/pypi/dm/PyHamcrest.svg?style=flat
    :alt: PyPI Package monthly downloads
    :target: https://pypi.python.org/pypi/PyHamcrest

Introduction
============

PyHamcrest is a framework for writing matcher objects, allowing you to
declaratively define "match" rules. There are a number of situations where
matchers are invaluable, such as UI validation, or data filtering, but it is in
the area of writing flexible tests that matchers are most commonly used. This
tutorial shows you how to use PyHamcrest for unit testing.

When writing tests it is sometimes difficult to get the balance right between
overspecifying the test (and making it brittle to changes), and not specifying
enough (making the test less valuable since it continues to pass even when the
thing being tested is broken). Having a tool that allows you to pick out
precisely the aspect under test and describe the values it should have, to a
controlled level of precision, helps greatly in writing tests that are "just
right." Such tests fail when the behavior of the aspect under test deviates
from the expected behavior, yet continue to pass when minor, unrelated changes
to the behaviour are made.

Installation
============

Hamcrest can be installed using the usual Python packaging tools. It depends on
distribute, but as long as you have a network connection when you install

BSD License  Copyright 2020 hamcrest.org All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  Neither the name of Hamcrest nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

mypy!=0.940; platform_python_implementation != 'PyPy' and extra == 'tests'

pytest-mypy-plugins; platform_python_implementation != 'PyPy' and extra == 'tests'

types-dataclasses; python_version < '3.7' and extra == 'tests'

pyhamcrest[tests]; extra == 'tests-numpy'

Programming Language :: Python :: Implementation :: CPython

Programming Language :: Python :: Implementation :: Jython

Programming Language :: Python :: Implementation :: PyPy

Topic :: Software Development :: Quality Assurance

Topic :: Software Development :: Testing


Summary: Highly concurrent networking library

Warning
=======

**New usages of eventlet are now heavily discouraged! Please read the
following.**

Eventlet was created almost 18 years ago, at a time where async
features were absent from the CPython stdlib. With time eventlet evolved and
CPython too, but since several years the maintenance activity of eventlet
decreased leading to a growing gap between eventlet and the CPython
implementation.

This gap is now too high and can lead you to unexpected side effects and bugs
in your applications.

Eventlet now follows a new maintenance policy. **Only maintenance for
stability and bug fixing** will be provided. **No new features will be
accepted**, except those related to the asyncio migration. **Usages in new
projects are discouraged**. **Our goal is to plan the retirement of eventlet**
and to give you ways to move away from eventlet.

If you are looking for a library to manage async network programming,
and if you do not yet use eventlet, then, we encourage you to use `asyncio`_,
which is the official async library of the CPython stdlib.

If you already use eventlet, we hope to enable migration to asyncio for some use
cases; see `Migrating off of Eventlet`_. Only new features related to the migration
solution will be accepted.

If you have questions concerning maintenance goals or concerning
the migration do not hesitate to `open a new issue`_, we will be happy to
answer them.

.. _asyncio: https://docs.python.org/3/library/asyncio.html
.. _open a new issue: https://github.com/eventlet/eventlet/issues/new
.. _Migrating off of Eventlet: https://eventlet.readthedocs.io/en/latest/asyncio/migration.html#migration-guide

Eventlet
========

.. image:: https://img.shields.io/pypi/v/eventlet
    :target: https://pypi.org/project/eventlet/

.. image:: https://img.shields.io/github/actions/workflow/status/eventlet/eventlet/test.yaml?branch=master
    :target: https://github.com/eventlet/eventlet/actions?query=workflow%3Atest+branch%3Amaster

.. image:: https://codecov.io/gh/e

Sergey Shepelev <temotor@gmail.com>, Jakub Stasiak <jakub@stasiak.at>, Tim Burke <tim.burke@gmail.com>, Nat Goodspeed <nat@lindenlab.com>, Itamar Turner-Trauring <itamar@itamarst.org>, Hervé Beraud <hberaud@redhat.com>

dnspython>=1.15.0
greenlet<3.4
black; extra == "dev"
build; extra == "dev"
commitizen; extra == "dev"
isort; extra == "dev"
pip-tools; extra == "dev"
pre-commit; extra == "dev"
twine; extra == "dev"

Operating System :: Microsoft :: Windows


Summary: parse() is the opposite of format()

Installation
------------

.. code-block:: pycon

    pip install parse

Usage
-----

Parse strings using a specification based on the Python `format()`_ syntax.

   ``parse()`` is the opposite of ``format()``

The module is set up to only export ``parse()``, ``search()``, ``findall()``,
and ``with_pattern()`` when ``import *`` is used:

>>> from parse import *

From there it's a simple thing to parse a string:

.. code-block:: pycon

    >>> parse("It's {}, I love it!", "It's spam, I love it!")
    <Result ('spam',) {}>
    >>> _[0]
    'spam'

Or to search a string for some pattern:

.. code-block:: pycon

    >>> search('Age: {:d}\n', 'Name: Rufus\nAge: 42\nColor: red\n')
    <Result (42,) {}>

Or find all the occurrences of some pattern in a string:

.. code-block:: pycon

    >>> ''.join(r[0] for r in findall(">{}<", "
the bold text
"))
    'the bold text'

If you're going to use the same pattern to match lots of strings you can
compile it once:

.. code-block:: pycon

    >>> from parse import compile
    >>> p = compile("It's {}, I love it!")
    >>> print(p)
    <Parser "It's {}, I love it!">
    >>> p.parse("It's spam, I love it!")
    <Result ('spam',) {}>

("compile" is not exported for ``import *`` usage as it would override the
built-in ``compile()`` function)

The default behaviour is to match strings case insensitively. You may match with
case by specifying `case_sensitive=True`:

.. code-block:: pycon

    >>> parse('SPAM', 'spam', case_sensitive=True) is None
    True

.. _format():
  https://docs.python.org/3/library/stdtypes.html#str.format

Format Syntax
-------------

A basic version of the `Format String Syntax`_ is supported with anonymous
(fixed-position), named and formatted fields::

   {[field name]:[format spec]}

Field names must be a valid Python identifiers, including dotted names;
element indexes imply dictionaries (see below for example).

Numbered fields are also not supported: the result of parsing will include
the par

Topic :: Software Development :: Code Generators


Summary: Safely add untrusted strings to HTML/XML markup.

# MarkupSafe

MarkupSafe implements a text object that escapes characters so it is
safe to use in HTML and XML. Characters that have special meanings are
replaced so that they display as the actual characters. This mitigates
injection attacks, meaning untrusted user input can safely be displayed
on a page.

## Examples

```pycon
>>> from markupsafe import Markup, escape

>>> # escape replaces special characters and wraps in Markup
>>> escape("<script>alert(document.cookie);</script>")
Markup('<script>alert(document.cookie);</script>')

>>> # wrap in Markup to mark text "safe" and prevent escaping
>>> Markup("<strong>Hello</strong>")
Markup('<strong>hello</strong>')

>>> escape(Markup("<strong>Hello</strong>"))
Markup('<strong>hello</strong>')

>>> # Markup is a str subclass
>>> # methods and operators escape their arguments
>>> template = Markup("Hello <em>{name}</em>")
>>> template.format(name='"World"')
Markup('Hello <em>"World"</em>')
```

## Donate

The Pallets organization develops and supports MarkupSafe and other
popular packages. In order to grow the community of contributors and
users, and allow the maintainers to devote more time to the projects,
[please donate today][].

[please donate today]: https://palletsprojects.com/donate

## Contributing

See our [detailed contributing documentation][contrib] for many ways to
contribute, including reporting issues, requesting features, asking or answering
questions, and making PRs.

[contrib]: https://palletsprojects.com/contributing/

Topic :: Internet :: WWW/HTTP :: Dynamic Content

Topic :: Text Processing :: Markup :: HTML


Summary: A pure Python implementation of a sliding window memory map manager

## Motivation

When reading from many possibly large files in a fashion similar to random access, it is usually the fastest and most efficient to use memory maps.

Although memory maps have many advantages, they represent a very limited system resource as every map uses one file descriptor, whose amount is limited per process. On 32 bit systems, the amount of memory you can have mapped at a time is naturally limited to theoretical 4GB of memory, which may not be enough for some applications.

## Limitations

* **System resources (file-handles) are likely to be leaked!** This is due to the library authors reliance on a deterministic `__del__()` destructor.
* The memory access is read-only by design.

## Overview

![Python package](https://github.com/gitpython-developers/smmap/workflows/Python%20package/badge.svg)

Smmap wraps an interface around mmap and tracks the mapped files as well as the amount of clients who use it. If the system runs out of resources, or if a memory limit is reached, it will automatically unload unused maps to allow continued operation.

To allow processing large files even on 32 bit systems, it allows only portions of the file to be mapped. Once the user reads beyond the mapped region, smmap will automatically map the next required region, unloading unused regions using a LRU algorithm.

Although the library can be used most efficiently with its native interface, a Buffer implementation is provided to hide these details behind a simple string-like interface.

For performance critical 64 bit applications, a simplified version of memory mapping is provided which always maps the whole file, but still provides the benefit of unloading unused mappings on demand.

## Prerequisites

* Python 3.7+
* OSX, Windows or Linux

The package was tested on all of the previously mentioned configurations.

## Installing smmap

[![Documentation Status](https://readthedocs.org/projects/smmap/badge/?version=latest)](https://readthedocs.org/projects/smmap/?badg

Programming Language :: Python :: 3 :: Only


Summary: GitPython is a Python library used to interact with Git repositories

![Python package](https://github.com/gitpython-developers/GitPython/workflows/Python%20package/badge.svg)
[![Documentation Status](https://readthedocs.org/projects/gitpython/badge/?version=stable)](https://readthedocs.org/projects/gitpython/?badge=stable)
[![Packaging status](https://repology.org/badge/tiny-repos/python:gitpython.svg)](https://repology.org/metapackage/python:gitpython/versions)

## [Gitoxide](https://github.com/Byron/gitoxide): A peek into the future…

I started working on GitPython in 2009, back in the days when Python was 'my thing' and I had great plans with it.
Of course, back in the days, I didn't really know what I was doing and this shows in many places. Somewhat similar to
Python this happens to be 'good enough', but at the same time is deeply flawed and broken beyond repair.

By now, GitPython is widely used and I am sure there is a good reason for that, it's something to be proud of and happy about.
The community is maintaining the software and is keeping it relevant for which I am absolutely grateful. For the time to come I am happy to continue maintaining GitPython, remaining hopeful that one day it won't be needed anymore.

More than 15 years after my first meeting with 'git' I am still in excited about it, and am happy to finally have the tools and
probably the skills to scratch that itch of mine: implement `git` in a way that makes tool creation a piece of cake for most.

If you like the idea and want to learn more, please head over to [gitoxide](https://github.com/Byron/gitoxide), an
implementation of 'git' in [Rust](https://www.rust-lang.org).

*(Please note that `gitoxide` is not currently available for use in Python, and that Rust is required.)*

## GitPython

GitPython is a python library used to interact with git repositories, high-level like git-porcelain,
or low-level like git-plumbing.

It provides abstractions of git objects for easy access of repository data often backed by calling the `git`
command-line program.

### DEVEL

typing-extensions>=3.10.0.2; python_version < "3.10"

basedpyright==1.39.9; (python_version >= "3.9" and sys_platform != "cygwin") and extra == "test"

mock; python_version < "3.8" and extra == "test"

mypy==1.18.2; python_version >= "3.9" and extra == "test"

typing-extensions; python_version < "3.11" and extra == "test"

sphinx-autodoc-typehints; extra == "doc"