Summary: unittest with plugins

.. image:: https://results.pre-commit.ci/badge/github/nose-devs/nose2/main.svg
   :target: https://results.pre-commit.ci/latest/github/nose-devs/nose2/main
   :alt: pre-commit.ci status

.. image:: https://github.com/nose-devs/nose2/workflows/build/badge.svg?event=push
    :alt: build status
    :target: https://github.com/nose-devs/nose2/actions?query=workflow%3Abuild

.. image:: https://readthedocs.org/projects/nose2/badge/
    :target: https://nose2.io/
    :alt: Documentation

.. image:: https://img.shields.io/pypi/v/nose2.svg
    :target: https://pypi.org/project/nose2/
    :alt: Latest PyPI version

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

.. image:: https://img.shields.io/badge/Mailing%20list-discuss%40nose2.io-blue.svg
    :target: https://groups.google.com/a/nose2.io/forum/#!forum/discuss
    :alt: Join discuss@nose2.io

Welcome to nose2
================

nose2's extends ``unittest`` to make testing nicer.

nose2 vs nose
-------------

``nose2`` originated as the successor to ``nose``.

``nose2`` is a distinct project and does not support all of the behaviors of ``nose``.
See `differences`_ for a thorough rundown.

nose2 vs pytest
---------------

`pytest`_ is an excellent test framework and we encourage users to consider
it for new projects.

It has a bigger team of maintainers and a larger community of users.

Quickstart
----------

Because ``nose2`` is based on unittest, you can start from the Python Standard
Library's `documentation for unittest <https://docs.python.org/library/unittest.html>`_
and then use nose2 to add value on top of that.

``nose2`` looks for tests in Python files whose names start with ``test`` and
runs every test function it discovers.

Here's an example of a simple test, written in typical unittest style:

.. code-block:: python

    # in test_simple.py
    import unittest

    class TestStrings(unittest.TestCase):
        def test

coverage; extra == "coverage-plugin"
sphinx; extra == "dev"
sphinx-issues; extra == "dev"
sphinx-rtd-theme; extra == "dev"


Summary: The property-based testing library for Python

# Hypothesis

* [Website](https://hypothesis.works/)
* [Documentation](https://hypothesis.readthedocs.io/en/latest/)
* [Source code](https://github.com/hypothesisWorks/hypothesis/)
* [Contributing](https://github.com/HypothesisWorks/hypothesis/blob/master/CONTRIBUTING.rst)
* [Community](https://hypothesis.readthedocs.io/en/latest/community.html)

Hypothesis is the property-based testing library for Python. With Hypothesis, you write tests which should pass for all inputs in whatever range you describe, and let Hypothesis randomly choose which of those inputs to check - including edge cases you might not have thought about. For example:

```python
from hypothesis import given, strategies as st

@given(st.lists(st.integers()))
def test_matches_builtin(ls):
    assert sorted(ls) == my_sort(ls)
```

This randomized testing can catch bugs and edge cases that you didn't think of and wouldn't have found. In addition, when Hypothesis does find a bug, it doesn't just report any failing test case — it reports the simplest possible one. This makes property-based tests a powerful tool for debugging, as well as testing.

For instance,

```python
def my_sort(ls):
    return sorted(set(ls))
```

fails with the simplest possible failing test case:

```
Failing test case: test_matches_builtin(ls=[0, 0])
```

### Installation

To install Hypothesis:

```
pip install hypothesis
```

There are also [optional extras available](https://hypothesis.readthedocs.io/en/latest/extras.html).

"David R. MacIver and Zac Hatfield-Dodds" <david@drmaciver.com>

exceptiongroup>=1.0.0; python_full_version < "3.11"

hypothesis-crosshair>=0.0.30; extra == "all"

tzdata>=2026.3; (sys_platform == "emscripten" and extra == "all") or (sys_platform == "win32" and extra == "all")

hypothesis-crosshair>=0.0.30; extra == "crosshair"

crosshair-tool>=0.0.109; extra == "crosshair"

python-dateutil>=1.4; extra == "dateutil"

dpcontracts>=0.4; extra == "dpcontracts"

tzdata>=2026.3; (sys_platform == "emscripten" and extra == "zoneinfo") or (sys_platform == "win32" and extra == "zoneinfo")

Development Status :: 5 - Production/Stable

Operating System :: Microsoft :: Windows

Programming Language :: Python :: 3 :: Only

Programming Language :: Python :: Implementation :: CPython

Programming Language :: Python :: Implementation :: PyPy

Topic :: Software Development :: Testing

python, testing, fuzzing, property-based-testing


Summary: Generic automation framework for acceptance testing and robotic process automation (RPA)

Robot Framework
===============

.. contents::
   :local:

Introduction
------------

`Robot Framework <http://robotframework.org>`_ |r| is a generic open source
automation framework for acceptance testing, acceptance test driven
development (ATDD), and robotic process automation (RPA). It has simple plain
text syntax and it can be extended easily with generic and custom libraries.

Robot Framework is operating system and application independent. It is
implemented using `Python <http://python.org>`_ which is also the primary
language to extend it. The framework has a rich ecosystem around it consisting
of various generic libraries and tools that are developed as separate projects.
For more information about Robot Framework and the ecosystem, see
http://robotframework.org.

Robot Framework project is hosted on GitHub_ where you can find source code,
an issue tracker, and some further documentation. Downloads are hosted on PyPI_.

Robot Framework development is sponsored by non-profit `Robot Framework Foundation
<http://robotframework.org/foundation>`_. If you are using the framework
and benefiting from it, consider joining the foundation to help maintaining
the framework and developing it further.

.. _GitHub: https://github.com/robotframework/robotframework
.. _PyPI: https://pypi.python.org/pypi/robotframework

.. image:: https://img.shields.io/pypi/v/robotframework.svg?label=version
   :target: https://pypi.python.org/pypi/robotframework
   :alt: Latest version

.. image:: https://img.shields.io/pypi/l/robotframework.svg
   :target: http://www.apache.org/licenses/LICENSE-2.0.html
   :alt: License

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

If you already have Python_ with `pip <https://pip.pypa.io>`_ installed,
you can simply run::

    pip install robotframework

For more detailed installation instructions, including installing Python, see
`INSTALL.rst <https://github.com/robotframework/robotframework/blob/master/INSTALL.rst>`__.

Robot Framework requires Python 3.8 or newer and

License :: OSI Approved :: Apache Software License

Topic :: Software Development :: Testing :: Acceptance

Topic :: Software Development :: Testing :: BDD

robotframework automation testautomation rpa testing acceptancetesting atdd bdd


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"

Programming Language :: Python :: Implementation :: Jython

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


Summary: Code coverage measurement for Python

.. Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
.. For details: https://github.com/coveragepy/coveragepy/blob/main/NOTICE.txt

===========
Coverage.py
===========

Code coverage measurement for Python.

.. image:: https://raw.githubusercontent.com/vshymanskyy/StandWithUkraine/main/banner2-direct.svg
    :target: https://vshymanskyy.github.io/StandWithUkraine
    :alt: Stand with Ukraine

-------------

|  |kit| |license| |versions|
|  |test-status| |quality-status| |docs| |metacov|
|  |tidelift| |sponsor| |stars| |mastodon-coveragepy| |mastodon-nedbat|
   |bluesky-nedbat|

Coverage.py measures code coverage, typically during test execution. It uses
the code analysis tools and tracing hooks provided in the Python standard
library to determine which lines are executable, and which have been executed.

Coverage.py runs on these versions of Python:

.. PYVERSIONS

* Python 3.10 through 3.15 beta, including free-threading.
* PyPy3 versions 3.10 and 3.11.

Documentation is on `Read the Docs`_.  Code repository and issue tracker are on
`GitHub`_.

.. _Read the Docs: https://coverage.readthedocs.io/en/7.15.3/
.. _GitHub: https://github.com/coveragepy/coveragepy

For Enterprise
--------------

.. |tideliftlogo| image:: https://nedbatchelder.com/pix/Tidelift_Logo_small.png
   :alt: Tidelift
   :target: https://tidelift.com/subscription/pkg/pypi-coverage?utm_source=pypi-coverage&utm_medium=referral&utm_campaign=readme

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

   * - |tideliftlogo|
     - `Available as part of the Tidelift Subscription. <https://tidelift.com/subscription/pkg/pypi-coverage?utm_source=pypi-coverage&utm_medium=referral&utm_campaign=readme>`_
       Coverage and thousands of other packages are working with
       Tidelift to deliver one enterprise subscription that covers all of the open
       source you use.  If you want the flexibility of open source and the confidence
       of commercial-grade software, this is for you.
       `Lea

tomli; python_full_version <= "3.11.0a6" and extra == "toml"

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

Topic :: Software Development :: Quality Assurance


Summary: tox is a generic virtualenv management and test command line tool

# tox

[![PyPI](https://img.shields.io/pypi/v/tox)](https://pypi.org/project/tox/)
[![Supported Python versions](https://img.shields.io/pypi/pyversions/tox.svg)](https://pypi.org/project/tox/)
[![Downloads](https://static.pepy.tech/badge/tox/month)](https://pepy.tech/project/tox)
[![Documentation status](https://readthedocs.org/projects/tox/badge/?version=latest)](https://tox.readthedocs.io/en/latest/?badge=latest)
[![check](https://github.com/tox-dev/tox/actions/workflows/check.yaml/badge.svg)](https://github.com/tox-dev/tox/actions/workflows/check.yaml)

`tox` aims to automate and standardize testing in Python. It is part of a larger vision of easing the packaging, testing
and release process of Python software (alongside [pytest](https://docs.pytest.org/en/latest/) and
[devpi](https://www.devpi.net)).

tox is a generic virtual environment management and test command line tool you can use for:

- checking your package builds and installs correctly under different environments (such as different Python
  implementations, versions or installation dependencies),
- running your tests in each of the environments with the test tool of choice,
- acting as a frontend to continuous integration servers, greatly reducing boilerplate and merging CI and shell-based
  testing.

Please read our [user guide](https://tox.wiki/en/latest/tutorial/getting-started.html) for an example and more detailed
introduction, or watch [this YouTube video](https://www.youtube.com/watch?v=SFqna5ilqig) that presents the problem space
and how tox solves it.

Bernát Gábor <gaborjbernat@gmail.com>, Jürgen Gmach <juergen.gmach@googlemail.com>, Rahul Devikar <rahuldevikar5512@gmail.com>

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

argcomplete>=3.6.3; extra == "completion"

devpi-process>=1.1.1; extra == "testing"

Topic :: Software Development :: Libraries

environments, isolated, testing, virtual


Green
=====

Green is a clean, colorful, fast python test runner.

Documentation
-------------

For full documentation please visit the `Github page for Green`_, or subscribe
to `Python Testing with Green`_ on Udemy.  You can find discounts for the Udemy
course in the documentation on Github.

Features
--------

- **Clean** - Low redundancy in output. Result statistics for each test is vertically aligned.
- **Colorful** - Terminal output makes good use of color when the terminal supports it.
- **Fast** - Tests run in independent processes.  (One per processor by default.  Does not play nicely with gevent.)
- **Powerful** - Multi-target + auto-discovery.
- **Traditional** - Use the normal ``unittest`` classes and methods for your unit tests.
- **Descriptive** - Multiple verbosity levels, from just dots to full docstring output.
- **Convenient** - Bash-completion and ZSH-completion of options and test targets.
- **Thorough** - Built-in integration with `coverage`_
- **Modern** - Supports Python 3.8+.  Additionally, `PyPy` is supported on a best-effort basis.
- **Portable** - macOS, Linux, and BSDs are fully supported.  Windows is supported on a best-effort basis.
- **Living** - This project grows and changes.  See the `changelog`_

.. _Github page for Green: https://github.com/CleanCut/green#green
.. _Python Testing with Green: https://www.udemy.com/python-testing-with-green/?couponCode=GREEN_ANGEL
.. _coverage: http://nedbatchelder.com/code/coverage/
.. _PyPy: http://pypy.org
.. _changelog: https://github.com/CleanCut/green/blob/main/CHANGELOG.md

coverage[toml]; python_full_version <= "3.11.0a6" and extra == "dev"

nose, nose2, trial, pytest, py.test, tox, green, , tdd, test, tests, functional, system, unit, unittest, , color, tabular, clean, red, rednose, regression, runner, , integration, smoke, white, black, box, incremental, end, , end-to-end, sanity, acceptance, load, stress, performance, , usability, install, uninstall, recovery, security, , comparison, alpha, beta, non-functional, destructive, , accessibility, internationalization, i18n, localization, l10n, , development, a/b, concurrent, conformance, verification, , validation, quality, assurance, ad-hoc, agile, api, , automated, all, pairs, pairwise, boundary, value, branch, , browser, condition, coverage, dynamic, exploratory, , equivalence, partitioning, fuzz, gui, glass, gorilla, , interface, keyword, penetration, retesting, risk, based, , scalability, soak, volume, vulnerability


FreezeGun: Let your Python tests travel through time
====================================================

.. image:: https://img.shields.io/pypi/v/freezegun.svg
   :target: https://pypi.python.org/pypi/freezegun/
.. image:: https://github.com/spulec/freezegun/workflows/CI/badge.svg
   :target: https://github.com/spulec/freezegun/actions
.. image:: https://coveralls.io/repos/spulec/freezegun/badge.svg?branch=master
   :target: https://coveralls.io/r/spulec/freezegun

FreezeGun is a library that allows your Python tests to travel through time by mocking the datetime module.

Usage
-----

Once the decorator or context manager have been invoked, all calls to datetime.datetime.now(), datetime.datetime.utcnow(), datetime.date.today(), time.time(), time.localtime(), time.gmtime(), and time.strftime() will return the time that has been frozen. time.monotonic() and time.perf_counter() will also be frozen, but as usual it makes no guarantees about their absolute value, only their changes over time.

Decorator
~~~~~~~~~

.. code-block:: python

    from freezegun import freeze_time
    import datetime
    import unittest

    # Freeze time for a pytest style test:

    @freeze_time("2012-01-14")
    def test():
        assert datetime.datetime.now() == datetime.datetime(2012, 1, 14)

    # Or a unittest TestCase - freezes for every test, and set up and tear down code

    @freeze_time("1955-11-12")
    class MyTests(unittest.TestCase):
        def test_the_class(self):
            assert datetime.datetime.now() == datetime.datetime(1955, 11, 12)

    # Or any other class - freezes around each callable (may not work in every case)

    @freeze_time("2012-01-14")
    class Tester(object):
        def test_the_class(self):
            assert datetime.datetime.now() == datetime.datetime(2012, 1, 14)

    # Or method decorator, might also pass frozen time object as kwarg

    class TestUnitTestMethodDecorator(unittest.TestCase):
        @freeze_time('2013-04-09')
        def test_


Summary: Database Abstraction Library

SQLAlchemy
==========

|PyPI| |Python| |Downloads|

.. |PyPI| image:: https://img.shields.io/pypi/v/sqlalchemy
    :target: https://pypi.org/project/sqlalchemy
    :alt: PyPI

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

.. |Downloads| image:: https://static.pepy.tech/badge/sqlalchemy/month
    :target: https://pepy.tech/project/sqlalchemy
    :alt: PyPI - Downloads

The Python SQL Toolkit and Object Relational Mapper

Introduction
-------------

SQLAlchemy is the Python SQL toolkit and Object Relational Mapper
that gives application developers the full power and
flexibility of SQL. SQLAlchemy provides a full suite
of well known enterprise-level persistence patterns,
designed for efficient and high-performing database
access, adapted into a simple and Pythonic domain
language.

Major SQLAlchemy features include:

* An industrial strength ORM, built
  from the core on the identity map, unit of work,
  and data mapper patterns.   These patterns
  allow transparent persistence of objects
  using a declarative configuration system.
  Domain models
  can be constructed and manipulated naturally,
  and changes are synchronized with the
  current transaction automatically.
* A relationally-oriented query system, exposing
  the full range of SQL's capabilities
  explicitly, including joins, subqueries,
  correlation, and most everything else,
  in terms of the object model.
  Writing queries with the ORM uses the same
  techniques of relational composition you use
  when writing SQL.  While you can drop into
  literal SQL at any time, it's virtually never
  needed.
* A comprehensive and flexible system
  of eager loading for related collections and objects.
  Collections are cached within a session,
  and can be loaded on individual access, all
  at once using joins, or by query per collection
  across the full result set.
* A Core SQL construction system and DBAPI

importlib-metadata; python_version < "3.8"

greenlet>=1; platform_machine == "aarch64" or (platform_machine == "ppc64le" or (platform_machine == "x86_64" or (platform_machine == "amd64" or (platform_machine == "AMD64" or (platform_machine == "win32" or platform_machine == "WIN32")))))

mysql-connector-python; extra == "mysql-connector"

oracledb>=1.0.1; extra == "oracle-oracledb"

greenlet>=1; extra == "postgresql-asyncpg"

psycopg2-binary; extra == "postgresql-psycopg2binary"

psycopg2cffi; extra == "postgresql-psycopg2cffi"

psycopg>=3.0.7; extra == "postgresql-psycopg"

psycopg[binary]>=3.0.7; extra == "postgresql-psycopgbinary"

typing_extensions!=3.10.0.1; extra == "aiosqlite"


    SQLModel, SQL databases in Python, designed for simplicity, compatibility, and robustness.

---

**Documentation**: [https://sqlmodel.tiangolo.com](https://sqlmodel.tiangolo.com)

**Source Code**: [https://github.com/fastapi/sqlmodel](https://github.com/fastapi/sqlmodel)

---

SQLModel is a library for interacting with SQL databases from Python code, with Python objects. It is designed to be intuitive, easy to use, highly compatible, and robust.

**SQLModel** is based on Python type annotations, and powered by [Pydantic](https://pydantic-docs.helpmanual.io/) and [SQLAlchemy](https://sqlalchemy.org/).

The key features are:

* **Intuitive to write**: Great editor support. Completion everywhere. Less time debugging. Designed to be easy to use and learn. Less time reading docs.
* **Easy to use**: It has sensible defaults and does a lot of work underneath to simplify the code you write.
* **Compatible**: It is designed to be compatible with **FastAPI**, Pydantic, and SQLAlchemy.
* **Extensible**: You have all the power of SQLAlchemy

Intended Audience :: System Administrators

Topic :: Database :: Database Engines/Servers

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


Summary: a little orm

.. image:: https://media.charlesleifer.com/blog/photos/peewee4-logo.png

peewee
======

Peewee is a simple and small ORM. It has few (but expressive) concepts, making
it easy to learn and intuitive to use.

Peewee is a single module with no required dependencies and has been running
production workloads of all sizes since 2010.

* a small, expressive ORM
* flexible query-builder that exposes full power of SQL
* supports sqlite, mysql, mariadb, postgresql
* `asyncio support <https://docs.peewee-orm.com/en/latest/peewee/asyncio.html>`__
  built on the standard async drivers (aiosqlite, asyncpg, aiomysql)
* tons of extensions
* use with `flask <https://docs.peewee-orm.com/en/latest/peewee/framework_integration.html#flask>`__,
  `fastapi <https://docs.peewee-orm.com/en/latest/peewee/framework_integration.html#fastapi>`__,
  `pydantic <https://docs.peewee-orm.com/en/latest/peewee/orm_utils.html#module-playhouse.pydantic_utils>`__, and
  `more <https://docs.peewee-orm.com/en/latest/peewee/framework_integration.html>`__.

New to peewee? These may help:

* `Quickstart <https://docs.peewee-orm.com/en/latest/peewee/quickstart.html#quickstart>`_
* `Example twitter app <https://docs.peewee-orm.com/en/latest/peewee/example.html#example>`_
* `Using peewee interactively <https://docs.peewee-orm.com/en/latest/peewee/interactive.html#interactive>`_
* `Models and fields <http://docs.peewee-orm.com/en/latest/peewee/models.html>`_
* `Querying <http://docs.peewee-orm.com/en/latest/peewee/querying.html>`_
* `Relationships and joins <http://docs.peewee-orm.com/en/latest/peewee/relationships.html>`_
* `Extensive library of SQL / Peewee examples <https://docs.peewee-orm.com/en/latest/peewee/query_library.html#query-library>`_
* `Flask setup <https://docs.peewee-orm.com/en/latest/peewee/framework_integration.html#flask>`_
  or `FastAPI setup <https://docs.peewee-orm.com/en/latest/peewee/framework_integration.html#fastapi>`_

Installation:

.. code-block:: console

    pip install peewee

Sql

pymysql; extra == "mysql"
psycopg2-binary; extra == "postgres"
psycopg[binary]; extra == "psycopg3"
cysqlite>=0.3.5; extra == "cysqlite"
aiosqlite; extra == "aiosqlite"
greenlet; extra == "aiosqlite"
aiomysql; extra == "aiomysql"
greenlet; extra == "aiomysql"
asyncpg; extra == "asyncpg"
greenlet; extra == "asyncpg"

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


Summary: Easy async ORM for python, built with relations in mind

============
Tortoise ORM
============

.. image:: https://img.shields.io/pypi/v/tortoise-orm.svg?style=flat
   :target: https://pypi.python.org/pypi/tortoise-orm
.. image:: https://pepy.tech/badge/tortoise-orm/month
   :target: https://pepy.tech/project/tortoise-orm
.. image:: https://github.com/tortoise/tortoise-orm/workflows/gh-pages/badge.svg
   :target: https://github.com/tortoise/tortoise-orm/actions?query=workflow:gh-pages
.. image:: https://github.com/tortoise/tortoise-orm/actions/workflows/ci.yml/badge.svg?branch=develop
   :target: https://github.com/tortoise/tortoise-orm/actions?query=workflow:ci
.. image:: https://coveralls.io/repos/github/tortoise/tortoise-orm/badge.svg
   :target: https://coveralls.io/github/tortoise/tortoise-orm

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

Tortoise ORM is an easy-to-use ``asyncio`` ORM *(Object Relational Mapper)* inspired by Django.

You can find the docs at `Documentation <https://tortoise.github.io>`_

Tortoise ORM supports CPython 3.10 and later for SQLite, MySQL, PostgreSQL, Microsoft SQL Server, and Oracle.

Why was Tortoise ORM built?
---------------------------

Tortoise ORM was built to provide a lightweight, async-native Object-Relational Mapper for Python with a familiar Django-like API.

Tortoise ORM performs well when compared to other Python ORMs. Here are `our benchmarks <https://github.com/tortoise/orm-benchmarks>`_ on PostgreSQL 17, where we measure different read and write operations (rows/sec, more is better):

.. image:: https://raw.githubusercontent.com/tortoise/tortoise-orm/develop/docs/ORM_Perf.png
    :target: https://github.com/tortoise/orm-benchmarks

How is an ORM useful?
---------------------

An Object-Relational Mapper (ORM) abstracts database interactions, allowing developers to work with databases using high-level, object-oriented code instead of raw SQL.

* Reduces boilerplate SQL, allowing faster development with cleaner, more readable code.
* Helps prevent SQL injection by using parameterized queries

Andrey Bondar <andrey@bondar.ru>, Nickolas Grigoriadis <nagrigoriadis@gmail.com>, long2ice <long2ice@gmail.com>

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

ciso8601; sys_platform != "win32" and implementation_name == "cpython" and extra == "accel"

uvloop; sys_platform != "win32" and implementation_name == "cpython" and extra == "accel"

psycopg[binary,pool]<4.0.0,>=3.0.12; extra == "psycopg"

asyncodbc<1.0.0,>=0.1.1; python_version < "4.0" and extra == "asyncodbc"

sql, mysql, postgres, psql, sqlite, aiosqlite, asyncpg, relational, database, rdbms, orm, object mapper, async, asyncio, aio, psycopg


Summary: An asyncio PostgreSQL driver

asyncpg -- A fast PostgreSQL Database Client Library for Python/asyncio
=======================================================================

.. image:: https://github.com/MagicStack/asyncpg/workflows/Tests/badge.svg
   :target: https://github.com/MagicStack/asyncpg/actions?query=workflow%3ATests+branch%3Amaster
   :alt: GitHub Actions status
.. image:: https://img.shields.io/pypi/v/asyncpg.svg
   :target: https://pypi.python.org/pypi/asyncpg

**asyncpg** is a database interface library designed specifically for
PostgreSQL and Python/asyncio.  asyncpg is an efficient, clean implementation
of PostgreSQL server binary protocol for use with Python's ``asyncio``
framework.  You can read more about asyncpg in an introductory
`blog post <http://magic.io/blog/asyncpg-1m-rows-from-postgres-to-python/>`_.

asyncpg requires Python 3.9 or later and is supported for PostgreSQL
versions 9.5 to 18.  Other PostgreSQL versions or other databases
implementing the PostgreSQL protocol *may* work, but are not being
actively tested.

Documentation
-------------

The project documentation can be found
`here <https://magicstack.github.io/asyncpg/current/>`_.

Performance
-----------

In our testing asyncpg is, on average, **5x** faster than psycopg3.

.. image:: https://raw.githubusercontent.com/MagicStack/asyncpg/master/performance.png?fddca40ab0
    :target: https://gistpreview.github.io/?0ed296e93523831ea0918d42dd1258c2

The above results are a geometric mean of benchmarks obtained with PostgreSQL
`client driver benchmarking toolbench <https://github.com/MagicStack/pgbench>`_
in June 2023 (click on the chart to see full details).

Features
--------

asyncpg implements PostgreSQL server protocol natively and exposes its
features directly, as opposed to hiding them behind a generic facade
like DB-API.

This enables asyncpg to have easy-to-use support for:

* **prepared statements**
* **scrollable cursors**
* **partial iteration** on query results
* automatic encoding and decoding o

async_timeout>=4.0.3; python_version < "3.11.0"

gssapi; platform_system != "Windows" and extra == "gssauth"

sspilib; platform_system == "Windows" and extra == "gssauth"

Development Status :: 5 - Production/Stable

Operating System :: Microsoft :: Windows

Programming Language :: Python :: 3 :: Only

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

Programming Language :: Python :: Implementation :: CPython


Summary: psycopg2 - Python-PostgreSQL Database Adapter

Psycopg is the most popular PostgreSQL database adapter for the Python
programming language.  Its main features are the complete implementation of
the Python DB API 2.0 specification and the thread safety (several threads can
share the same connection).  It was designed for heavily multi-threaded
applications that create and destroy lots of cursors and make a large number
of concurrent "INSERT"s or "UPDATE"s.

Psycopg 2 is mostly implemented in C as a libpq wrapper, resulting in being
both efficient and secure.  It features client-side and server-side cursors,
asynchronous communication and notifications, "COPY TO/COPY FROM" support.
Many Python types are supported out-of-the-box and adapted to matching
PostgreSQL data types; adaptation can be extended and customized thanks to a
flexible objects adaptation system.

Psycopg 2 is both Unicode and Python 3 friendly.

.. Note::

    The psycopg2 package is still widely used and actively maintained, but it
    is not expected to receive new features.

    `Psycopg 3`__ is the evolution of psycopg2 and is where `new features are
    being developed`__: if you are starting a new project you should probably
    start from 3!

    .. __: https://pypi.org/project/psycopg/
    .. __: https://www.psycopg.org/psycopg3/docs/index.html

Documentation
-------------

Documentation is included in the ``doc`` directory and is `available online`__.

.. __: https://www.psycopg.org/docs/

For any other resource (source code repository, bug tracker, mailing list)
please check the `project homepage`__.

.. __: https://psycopg.org/

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

Building Psycopg requires a few prerequisites (a C compiler, some development
packages): please check the install_ and the faq_ documents in the ``doc`` dir
or online for the details.

If prerequisites are met, you can install psycopg like any other Python
package, using ``pip`` to download it from PyPI_::

    $ pip install psycopg2

or using ``setup.py`` if you have downloaded the

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


Summary: PyMongo - the Official MongoDB Python driver

# PyMongo

[![PyPI Version](https://img.shields.io/pypi/v/pymongo)](https://pypi.org/project/pymongo)
[![Python Versions](https://img.shields.io/pypi/pyversions/pymongo)](https://pypi.org/project/pymongo)
[![Monthly Downloads](https://static.pepy.tech/badge/pymongo/month)](https://pepy.tech/project/pymongo)
[![API Documentation Status](https://readthedocs.org/projects/pymongo/badge/?version=stable)](http://pymongo.readthedocs.io/en/stable/api?badge=stable)
[![codecov](https://codecov.io/gh/mongodb/mongo-python-driver/graph/badge.svg?branch=master)](https://codecov.io/gh/mongodb/mongo-python-driver)

## About

The PyMongo distribution contains tools for interacting with MongoDB
database from Python. The `bson` package is an implementation of the
[BSON format](http://bsonspec.org) for Python. The `pymongo` package is
a native Python driver for MongoDB, offering both synchronous and asynchronous APIs. The `gridfs` package is a
[gridfs](https://github.com/mongodb/specifications/blob/master/source/gridfs/gridfs-spec.md/)
implementation on top of `pymongo`.

PyMongo supports MongoDB 4.0, 4.2, 4.4, 5.0, 6.0, 7.0, and 8.0. PyMongo follows [semantic versioning](https://semver.org/spec/v2.0.0.html) for its releases.

## Documentation

Documentation is available at
[mongodb.com](https://www.mongodb.com/docs/languages/python/pymongo-driver/current/).

[API documentation](https://pymongo.readthedocs.io/en/stable/api/) and the [full changelog](https://pymongo.readthedocs.io/en/stable/changelog.html) for each release is available at [readthedocs.io](https://pymongo.readthedocs.io/en/stable/index.html).

## Support / Feedback

For issues with, questions about, or feedback for PyMongo, please look
into our [support channels](https://support.mongodb.com/welcome). Please
do not email any of the PyMongo developers directly with issues or
questions - you're more likely to get an answer on
[StackOverflow](https://stackoverflow.com/questions/tagged/mongodb)
(using a "mongodb" tag).

## Bu

pymongo-auth-aws<2.0.0,>=1.1.0; extra == "aws"

readthedocs-sphinx-search~=0.3; extra == "docs"

sphinx-autobuild>=2020.9.1; extra == "docs"

sphinxcontrib-shellcheck<2,>=1; extra == "docs"

certifi>=2023.7.22; (os_name == "nt" or sys_platform == "darwin") and extra == "encryption"

pymongo-auth-aws<2.0.0,>=1.1.0; extra == "encryption"

pymongocrypt<2.0.0,>=1.13.0; extra == "encryption"

pykerberos>=1.2.4; os_name != "nt" and extra == "gssapi"

winkerberos>=0.5.0; os_name == "nt" and extra == "gssapi"

certifi>=2023.7.22; (os_name == "nt" or sys_platform == "darwin") and extra == "ocsp"

service-identity>=23.1.0; extra == "ocsp"

importlib-metadata>=7.0; python_version < "3.13" and extra == "test"

backports-zstd>=1.0.0; python_version < "3.14" and extra == "zstd"

Programming Language :: Python :: Implementation :: PyPy


Summary: Python client for Redis database and key-value store

# redis-py

The Python interface to the Redis key-value store.

[![CI](https://github.com/redis/redis-py/actions/workflows/integration.yaml/badge.svg?branch=master)](https://github.com/redis/redis-py/actions/workflows/integration.yaml)
[![docs](https://readthedocs.org/projects/redis/badge/?version=stable&style=flat)](https://redis.readthedocs.io/en/stable/)
[![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/redis/redis-py/blob/master/LICENSE)
[![pypi](https://badge.fury.io/py/redis.svg)](https://pypi.org/project/redis/)
[![pre-release](https://img.shields.io/github/v/release/redis/redis-py?include_prereleases&label=latest-prerelease)](https://github.com/redis/redis-py/releases)
[![codecov](https://codecov.io/gh/redis/redis-py/branch/master/graph/badge.svg?token=yenl5fzxxr)](https://codecov.io/gh/redis/redis-py)

[Installation](#installation) |  [Usage](#usage) | [Advanced Topics](#advanced-topics) | [Contributing](https://github.com/redis/redis-py/blob/master/CONTRIBUTING.md)

---------------------------------------------

**Note:** redis-py 5.0 is the last version of redis-py that supports Python 3.7, as it has reached [end of life](https://devguide.python.org/versions/). redis-py 5.1 supports Python 3.8+.<br>
**Note:** redis-py 6.1.0 is the last version of redis-py that supports Python 3.8, as it has reached [end of life](https://devguide.python.org/versions/). redis-py 6.2.0 supports Python 3.9+.

---------------------------------------------

## How do I Redis?

[Learn for free at Redis University](https://redis.io/learn/university)

[Try the Redis Cloud](https://redis.io/try-free/)

[Dive in developer tutorials](https://redis.io/learn)

[Join the Redis community](https://redis.io/community/)

[Work at Redis](https://redis.io/careers/)

## Installation

Start a redis via docker (for Redis versions >= 8.0):

``` bash
docker run -p 6379:6379 -it redis:latest
```

Start a redis via docker (for Redis versions < 8.0):

``` bash
do

async-timeout>=4.0.3; python_full_version < "3.11.3"

pybreaker>=1.4.0; extra == "circuit-breaker"

opentelemetry-api>=1.39.1; extra == "otel"

opentelemetry-exporter-otlp-proto-http>=1.39.1; extra == "otel"

opentelemetry-sdk>=1.39.1; extra == "otel"


Summary: DuckDB in-process database

  <picture>
    <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/duckdb/duckdb/refs/heads/main/logo/DuckDB_Logo-horizontal.svg">
    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/duckdb/duckdb/refs/heads/main/logo/DuckDB_Logo-horizontal-dark-mode.svg">

  </picture>

  DuckDB.org
  |
  User Guide (Python)
  -
  API Docs (Python)

# DuckDB: A Fast, In-Process, Portable, Open Source, Analytical Database System

* **Simple**: DuckDB is easy to install and deploy. It has zero external dependencies and runs in-process in its host application or as a single binary.
* **Portable**: DuckDB runs on Linux, macOS, Windows, Android, iOS and all popular hardware architectures. It has idiomatic client APIs for major programming languages.
* **Feature-rich**: DuckDB offers a rich SQL dialect. It can read and write file formats such as CSV, Parquet, and JSON, to and from the local file system and remote endpoints such as S3 buckets.
* **Fast**: DuckDB runs analytical queries at blazing speed thanks to its columnar engine, which supports parallel execution and can process larger-than-memory workloads.
* **Extensible**: DuckDB is extensible by third-party features such as new data types, functions, file formats and new SQL syntax. User contributions are available as co

ipython; extra == "all"
fsspec; extra == "all"
numpy; extra == "all"
pandas; extra == "all"
pyarrow; extra == "all"
adbc-driver-manager; extra == "all"

Intended Audience :: Information Technology


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


Summary: Tensors and Dynamic neural networks in Python with strong GPU acceleration

![PyTorch Logo](https://github.com/pytorch/pytorch/raw/main/docs/source/_static/img/pytorch-logo-dark.png)

--------------------------------------------------------------------------------

PyTorch is a Python package that provides two high-level features:
- Tensor computation (like NumPy) with strong GPU acceleration
- Deep neural networks built on a tape-based autograd system

You can reuse your favorite Python packages such as NumPy, SciPy, and Cython to extend PyTorch when needed.

Our trunk health (Continuous Integration signals) can be found at [hud.pytorch.org](https://hud.pytorch.org/ci/pytorch/pytorch/main).

<!-- toc -->

- [More About PyTorch](#more-about-pytorch)
  - [A GPU-Ready Tensor Library](#a-gpu-ready-tensor-library)
  - [Dynamic Neural Networks: Tape-Based Autograd](#dynamic-neural-networks-tape-based-autograd)
  - [Python First](#python-first)
  - [Imperative Experiences](#imperative-experiences)
  - [Fast and Lean](#fast-and-lean)
  - [Extensions Without Pain](#extensions-without-pain)
- [Installation](#installation)
  - [Binaries](#binaries)
    - [NVIDIA Jetson Platforms](#nvidia-jetson-platforms)
  - [From Source](#from-source)
    - [Prerequisites](#prerequisites)
      - [NVIDIA CUDA Support](#nvidia-cuda-support)
      - [AMD ROCm Support](#amd-rocm-support)
      - [Intel GPU Support](#intel-gpu-support)
    - [Get the PyTorch Source](#get-the-pytorch-source)
    - [Install Dependencies](#install-dependencies)
    - [Install PyTorch](#install-pytorch)
      - [Adjust Build Options (Optional)](#adjust-build-options-optional)
  - [Docker Image](#docker-image)
    - [Using pre-built images](#using-pre-built-images)
    - [Building the image yourself](#building-the-image-yourself)
  - [Building the Documentation](#building-the-documentation)
    - [Troubleshooting CI Errors](#troubleshooting-ci-errors)
    - [Building a PDF](#building-a-pdf)
  - [Previous Versions](#previous-versions)
- [Getting Started](#getting-started)
- [Resources](#reso

Apache-2.0 AND Apache-2.0 WITH LLVM-exception AND BSD-2-Clause AND BSD-3-Clause AND BSL-1.0 AND MIT

cuda-bindings<14,>=13.0.3; platform_system == "Linux" and python_version < "3.15"

nvidia-cudnn-cu13==9.20.0.48; platform_system == "Linux"

nvidia-cusparselt-cu13==0.8.1; platform_system == "Linux"

nvidia-nccl-cu13==2.29.7; platform_system == "Linux"

nvidia-nvshmem-cu13==3.4.5; platform_system == "Linux"

triton==3.7.1; platform_system == "Linux" and python_version < "3.15"

Topic :: Scientific/Engineering :: Artificial Intelligence

Topic :: Scientific/Engineering :: Mathematics


Summary: TensorFlow is an open source machine learning framework for everyone.

[![Python](https://img.shields.io/pypi/pyversions/tensorflow.svg?style=plastic)](https://badge.fury.io/py/tensorflow)
[![PyPI](https://badge.fury.io/py/tensorflow.svg)](https://badge.fury.io/py/tensorflow)

TensorFlow is an open source software library for high performance numerical
computation. Its flexible architecture allows easy deployment of computation
across a variety of platforms (CPUs, GPUs, TPUs), and from desktops to clusters
of servers to mobile and edge devices.

Originally developed by researchers and engineers from the Google Brain team
within Google's AI organization, it comes with strong support for machine
learning and deep learning and the flexible numerical computation core is used
across many other scientific domains. TensorFlow is licensed under [Apache
2.0](https://github.com/tensorflow/tensorflow/blob/master/LICENSE).

nvidia-cublas-cu12<13.0,>=12.5.3.2; extra == "and-cuda"

nvidia-cuda-cupti-cu12<13.0,>=12.5.82; extra == "and-cuda"

nvidia-cuda-nvcc-cu12<13.0,>=12.5.82; extra == "and-cuda"

nvidia-cuda-nvrtc-cu12<13.0,>=12.5.82; extra == "and-cuda"

nvidia-cuda-runtime-cu12<13.0,>=12.5.82; extra == "and-cuda"

nvidia-cusolver-cu12<12.0,>=11.6.3.83; extra == "and-cuda"

nvidia-cusparse-cu12<13.0,>=12.5.1.3; extra == "and-cuda"

nvidia-nccl-cu12<3.0,>=2.27.7; extra == "and-cuda"

nvidia-nvjitlink-cu12<13.0,>=12.5.82; extra == "and-cuda"

tensorflow-io-gcs-filesystem>=0.23.1; (sys_platform != "win32" and python_version < "3.13") and extra == "gcs-filesystem"

tensorflow-io-gcs-filesystem>=0.23.1; (sys_platform == "win32" and python_version < "3.12") and extra == "gcs-filesystem"

Environment :: GPU :: NVIDIA CUDA :: 12 :: 12.2

License :: OSI Approved :: Apache Software License

Topic :: Software Development :: Libraries


Summary: Multi-backend Keras

# Keras 3: Deep Learning for Humans

Keras 3 is a multi-backend deep learning framework, with support for JAX, TensorFlow, PyTorch, and OpenVINO (for inference-only).
Effortlessly build and train models for computer vision, natural language processing, audio processing,
timeseries forecasting, recommender systems, etc.

- **Accelerated model development**: Ship deep learning solutions faster thanks to the high-level UX of Keras
and the availability of easy-to-debug runtimes like PyTorch or JAX eager execution.
- **State-of-the-art performance**: By picking the backend that is the fastest for your model architecture (often JAX!),
leverage speedups ranging from 20% to 350% compared to other frameworks. [Benchmark here](https://keras.io/getting_started/benchmarks/).
- **Datacenter-scale training**: Scale confidently from your laptop to large clusters of GPUs or TPUs.

Join nearly three million developers, from burgeoning startups to global enterprises, in harnessing the power of Keras 3.

## Installation

### Install with pip

Keras 3 is available on PyPI as `keras`. Note that Keras 2 remains available as the `tf-keras` package.

1. Install `keras`:

```
pip install keras --upgrade
```

2. Install backend package(s).

To use `keras`, you should also install the backend of choice: `tensorflow`, `jax`, or `torch`. Additionally,
The `openvino` backend is available with support for model inference only.

### Local installation

#### Minimal installation

Keras 3 is compatible with Linux and macOS systems. For Windows users, we recommend using WSL2 to run Keras.
To install a local development version:

1. Install dependencies:

```
pip install -r requirements.txt
```

2. Run installation command from the root directory.

```
python pip_build.py --install
```

3. Run API generation script when creating PRs that update `keras_export` public APIs:

```
./shell/api_gen.sh
```

## Backend Compatibility Table

The following table lists the minimum supported versions of each back

absl-py numpy rich namex h5py optree ml-dtypes packaging


Summary: Transformers: the model-definition framework for state-of-the-art machine learning models in text, vision, audio, and multimodal models, for both inference and training.

  <picture>
    <source media="(prefers-color-scheme: dark)" srcset="https://huggingface.co/datasets/huggingface/documentation-images/raw/main/transformers-logo-dark.svg">
    <source media="(prefers-color-scheme: light)" srcset="https://huggingface.co/datasets/huggingface/documentation-images/raw/main/transformers-logo-light.svg">

  </picture>

    <a href="https://github.com

The Hugging Face team (past and future) with the help of all our contributors (https://github.com/huggingface/transformers/graphs/contributors)

transformers-mlinter==0.1.2; extra == "quality"

kernels<0.16,>=0.15.2; extra == "kernels"

sentencepiece!=0.1.92,>=0.1.91; extra == "sentencepiece"

mistral-common[image]>=1.11.5; extra == "mistral-common"

accelerate>=1.1.0; extra == "accelerate"

kernels<0.16,>=0.15.2; extra == "integrations"

codecarbon>=2.8.1; extra == "integrations"

ray[tune]>=2.7.0; extra == "integrations"

codecarbon>=2.8.1; extra == "codecarbon"

optimum-benchmark>=0.3.0; extra == "benchmark"

sudachidict_core>=20220729; extra == "ja"

pytest-asyncio>=1.2.0; extra == "testing"

pytest-rerunfailures<16.0; extra == "testing"

sacrebleu<2.0.0,>=1.4.12; extra == "testing"

transformers-mlinter==0.1.2; extra == "testing"

sentencepiece!=0.1.92,>=0.1.91; extra == "testing"

mistral-common[image]>=1.11.5; extra == "testing"

deepspeed>=0.9.3; extra == "deepspeed-testing"

accelerate>=1.1.0; extra == "deepspeed-testing"

pytest<9.0.0,>=7.2.0; extra == "deepspeed-testing"

pytest-asyncio>=1.2.0; extra == "deepspeed-testing"

pytest-random-order; extra == "deepspeed-testing"

pytest-rich; extra == "deepspeed-testing"

pytest-xdist; extra == "deepspeed-testing"

pytest-order; extra == "deepspeed-testing"

pytest-rerunfailures<16.0; extra == "deepspeed-testing"

pytest-timeout; extra == "deepspeed-testing"

pytest-env; extra == "deepspeed-testing"

timeout-decorator; extra == "deepspeed-testing"

parameterized>=0.9; extra == "deepspeed-testing"

dill<0.3.5; extra == "deepspeed-testing"

evaluate>=0.4.6; extra == "deepspeed-testing"

nltk<=3.8.1; extra == "deepspeed-testing"

sacremoses; extra == "deepspeed-testing"

beautifulsoup4; extra == "deepspeed-testing"

tensorboard; extra == "deepspeed-testing"

sacrebleu<2.0.0,>=1.4.12; extra == "deepspeed-testing"

hf-doc-builder; extra == "deepspeed-testing"

datasets>=2.15.0; extra == "deepspeed-testing"

ruff==0.14.10; extra == "deepspeed-testing"

GitPython<3.1.19; extra == "deepspeed-testing"

urllib3<2.0.0; extra == "deepspeed-testing"

ty==0.0.20; extra == "deepspeed-testing"

transformers-mlinter==0.1.2; extra == "deepspeed-testing"

sentencepiece!=0.1.92,>=0.1.91; extra == "deepspeed-testing"

openai>=1.98.0; extra == "deepspeed-testing"

pydantic>=2; extra == "deepspeed-testing"

torch>=2.4; extra == "deepspeed-testing"

mistral-common[image]>=1.11.5; extra == "deepspeed-testing"

mistral-common[image]>=1.11.5; extra == "all"

mistral-common[image]>=1.11.5; extra == "dev"

pytest-rerunfailures<16.0; extra == "dev"

transformers-mlinter==0.1.2; extra == "dev"

sudachidict_core>=20220729; extra == "dev"

machine-learning nlp python pytorch transformer llm vlm deep-learning inference training model-hub pretrained-models llama gemma qwen


Summary: XGBoost Python Package

======================
XGBoost Python Package
======================

|PyPI version|

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

From `PyPI <https://pypi.python.org/pypi/xgboost>`_
---------------------------------------------------

For a stable version, install using ``pip``::

    pip install xgboost

.. |PyPI version| image:: https://badge.fury.io/py/xgboost.svg
   :target: http://badge.fury.io/py/xgboost

For building from source, see `build <https://xgboost.readthedocs.io/en/latest/build.html>`_.

Hyunsu Cho <chohyu01@cs.washington.edu>, Jiaming Yuan <jm.yuan@outlook.com>

nvidia-nccl-cu12; platform_system == "Linux"


Summary: LightGBM Python-package

LightGBM Python-package
=======================

|License| |Python Versions| |PyPI Version| |PyPI Downloads| |conda Version| |conda Downloads| |API Docs|

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

Preparation
'''''''''''

32-bit Python is not supported.
Please install 64-bit version.
If you have a strong need to install with 32-bit Python, refer to `Build 32-bit Version with 32-bit Python section <#build-32-bit-version-with-32-bit-python>`__.

|

Install from `PyPI <https://pypi.org/project/lightgbm>`_
''''''''''''''''''''''''''''''''''''''''''''''''''''''''

.. code:: sh

    pip install lightgbm

Compiled library that is included in the wheel file supports both **GPU** (don't confuse with CUDA version) and **CPU** versions out of the box.
This feature is available only for **Windows** and **Linux** currently.
To use **GPU** version you only need to install OpenCL Runtime libraries.
For NVIDIA and AMD GPU they are included in the ordinary drivers for your graphics card, so no action is required.
If you would like your AMD or Intel CPU to act like a GPU (for testing and debugging),
you can install `AMD APP SDK <https://github.com/lightgbm-org/LightGBM/releases/download/v2.0.12/AMD-APP-SDKInstaller-v3.0.130.135-GA-windows-F-x64.exe>`_ on **Windows** and `PoCL <https://portablecl.org>`_ on **Linux**.
Many modern Linux distributions provide packages for PoCL, look for ``pocl-opencl-icd`` on Debian-based distributions and ``pocl`` on RedHat-based distributions.

For **Windows** users, `VC runtime <https://learn.microsoft.com/en-us/cpp/windows/latest-supported-vc-redist>`_ is needed if **Visual Studio** is not installed.

For **macOS** users, the **OpenMP** library is needed.
You can install it by the following command: ``brew install libomp``.

|

Install Nightly Packages
''''''''''''''''''''''''

Python packages are built on each new commit to ``main`` and uploaded to https://anaconda.org/lightgbm-packages.

Only the latest development version is available there, and can be installed

dask[array,dataframe,distributed]>=2.0.0; extra == "dask"

scikit-learn>=1.0.2; extra == "scikit-learn"


Summary: CatBoost Python Package

CatBoost is a fast, scalable, high performance gradient boosting on decision trees library. Used for ranking, classification, regression and other ML tasks.

graphviz
matplotlib
numpy<3.0,>=1.16.0
pandas<4.0,>=0.24
scipy
plotly
six
traitlets; extra == "widget"
ipython; extra == "widget"
ipywidgets<9.0,>=7.0; extra == "widget"


Summary: State-of-the-art diffusion in PyTorch and JAX.

🤗 Diffusers is the go-to library for state-of-the-art pretrained diffusion models for generating images, audio, and even 3D structures of molecules. Whether you're looking for a simple inference solution or training your own diffusion models, 🤗 Diffusers is a modular toolbox that supports both. Our library is designed with a focus on [usability over performance](https://huggingface.co/docs/di

The Hugging Face team (past and future) with the help of all our contributors (https://github.com/huggingface/diffusers/graphs/contributors)

hf-doc-builder>=0.3.0; extra == "quality"

protobuf<4,>=3.20.3; extra == "training"

invisible-watermark>=0.2.0; extra == "test"

sentencepiece!=0.1.92,>=0.1.91; extra == "test"

bitsandbytes>=0.43.3; extra == "bitsandbytes"

accelerate>=0.31.0; extra == "bitsandbytes"

optimum_quanto>=0.2.6; extra == "optimum-quanto"

accelerate>=0.31.0; extra == "optimum-quanto"

nvidia_modelopt[hf]>=0.33.1; extra == "nvidia-modelopt"

invisible-watermark>=0.2.0; extra == "dev"

deep learning diffusion jax pytorch stable diffusion audioldm


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"


Summary: PyTorch Image Models

# PyTorch Image Models
- [What's New](#whats-new)
- [Introduction](#introduction)
- [Models](#models)
- [Features](#features)
- [Results](#results)
- [Getting Started (Documentation)](#getting-started-documentation)
- [Train, Validation, Inference Scripts](#train-validation-inference-scripts)
- [Awesome PyTorch Resources](#awesome-pytorch-resources)
- [Licenses](#licenses)
- [Citing](#citing)

## What's New

## July 10, 2026
* Improve optimizer `torch.compile` and tensor learning-rate support.
* Extend NaFlexViT patch-layout (for NaFlex-CLAP), and `forward_intermediates` (NaFlex dict input) support.
* Harden pickle loading and improve custom-label inference.
* Release 1.0.28

## May 27, 2026
* Add model defs and pretrained weights for EUPE ViT (DINOv3-style) and ConvNeXt models. See the [Efficient Universal Perception Encoder paper](https://arxiv.org/abs/2603.22387).
* Add TIPSv2 model defs and pretrained weights for (DINOv2-style) ViTs. See the [TIPSv2 paper](https://arxiv.org/abs/2604.12012).

## May 8, 2026
* Release 1.0.27

## April 23, 2026
* Add Gemma4 ViT encoders w/ NaFlex pipeline support (variable aspect/size per image). Thanks [Yonghye Kwon](https://github.com/developer0hye)
* Support DINOv3 weights in NaFlexVit. Thanks [Yonghye Kwon](https://github.com/developer0hye)
* Some improvements to Muon fallback (AdamW/NadamW) lr behavior

## March 23, 2026
* Improve pickle checkpoint handling security. Default all loading to `weights_only=True`, add safe_global for ArgParse.
* Improve attention mask handling for core ViT/EVA models & layers. Resolve bool masks, pass `is_causal` through for SSL tasks.
* Fix class & register token uses with ViT and no pos embed enabled.
* Add Patch Representation Refinement (PRR) as a pooling option in ViT. Thanks Sina (https://github.com/sinahmr).
* Improve consistency of output projection / MLP dimensions for attention pooling layers.
* Hiera model F.SDPA optimization to allow Flash Attention kernel use.
* Caution added to SGDP

torch torchvision pyyaml huggingface_hub safetensors


Summary: A high-level Python web framework that encourages rapid development and clean, pragmatic design.

======
Django
======

Django is a high-level Python web framework that encourages rapid development
and clean, pragmatic design. Thanks for checking it out.

All documentation is in the "``docs``" directory and online at
https://docs.djangoproject.com/en/stable/. If you're just getting started,
here's how we recommend you read the docs:

* First, read ``docs/intro/install.txt`` for instructions on installing Django.

* Next, work through the tutorials in order (``docs/intro/tutorial01.txt``,
  ``docs/intro/tutorial02.txt``, etc.).

* If you want to set up an actual deployment server, read
  ``docs/howto/deployment/index.txt`` for instructions.

* You'll probably want to read through the topical guides (in ``docs/topics``)
  next; from there you can jump to the HOWTOs (in ``docs/howto``) for specific
  problems, and check out the reference (``docs/ref``) for gory details.

* See ``docs/README`` for instructions on building an HTML version of the docs.

Docs are updated rigorously. If you find any problems in the docs, or think
they should be clarified in any way, please take 30 seconds to fill out a
ticket here: https://code.djangoproject.com/newticket

To get more help:

* Join the `Django Discord community <https://chat.djangoproject.com>`_.

* Join the community on the `Django Forum <https://forum.djangoproject.com/>`_.

To contribute to Django:

* Check out https://docs.djangoproject.com/en/dev/internals/contributing/ for
  information about getting involved.

To run Django's test suite:

* Follow the instructions in the "Unit tests" section of
  ``docs/internals/contributing/writing-code/unit-tests.txt``, published online at
  https://docs.djangoproject.com/en/dev/internals/contributing/writing-code/unit-tests/#running-the-unit-tests

Supporting the Development of Django
====================================

Django's development depends on your contributions.

If you depend on Django, remember to support the Django Software Foundation: https://www.djangoproject.

Django Software Foundation <foundation@djangoproject.com>

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

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


Summary: A simple framework for building complex web applications.

# Flask

Flask is a lightweight [WSGI] web application framework. It is designed
to make getting started quick and easy, with the ability to scale up to
complex applications. It began as a simple wrapper around [Werkzeug]
and [Jinja], and has become one of the most popular Python web
application frameworks.

Flask offers suggestions, but doesn't enforce any dependencies or
project layout. It is up to the developer to choose the tools and
libraries they want to use. There are many extensions provided by the
community that make adding new functionality easy.

[WSGI]: https://wsgi.readthedocs.io/
[Werkzeug]: https://werkzeug.palletsprojects.com/
[Jinja]: https://jinja.palletsprojects.com/

## A Simple Example

```python
# save this as app.py
from flask import Flask

app = Flask(__name__)

@app.route("/")
def hello():
    return "Hello, World!"
```

```
$ flask run
  * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
```

## Donate

The Pallets organization develops and supports Flask and the libraries
it uses. 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/

importlib-metadata>=3.6.0; python_version < "3.10"

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


    FastAPI framework, high performance, easy to learn, fast to code, ready for production

---

**Documentation**: [https://fastapi.tiangolo.com](https://fastapi.tiangolo.com)

**Source Code**: [https://github.com/fastapi/fastapi](https://github.com/fastapi/fastapi)

---

FastAPI is a modern, fast (high-performance), web framework for building APIs with Python based on standard Python type hints.

The key features are:

* **Fast**: Very high performance, on par with **NodeJS** and **Go** (thanks to Starlette and Pydantic). [One of the fastest Python frameworks available](#performance).
* **Fast to code**: Increase the speed to develop features by about 200% to 300%. *
* **Fewer bugs**: Reduce about 40% of human (developer) induced errors. *
* **Intuitive**: Great editor support. <dfn title="also known as auto-complete, autocompletion, IntelliSense">Completion</dfn> everywhere. Less time debugging.
* **Easy**: Designed to be easy to use and learn. Less time reading docs.
* **Short**: Minimize code duplication. Multiple featur

fastapi-cli[standard]>=0.0.32; extra == "standard"

python-multipart>=0.0.18; extra == "standard"

email-validator>=2.0.0; extra == "standard"

uvicorn[standard]>=0.12.0; extra == "standard"

pydantic-settings>=2.0.0; extra == "standard"

pydantic-extra-types>=2.0.0; extra == "standard"

fastapi-cli[standard-no-fastapi-cloud-cli]>=0.0.32; extra == "standard-no-fastapi-cloud-cli"

httpx<1.0.0,>=0.23.0; extra == "standard-no-fastapi-cloud-cli"

jinja2>=3.1.5; extra == "standard-no-fastapi-cloud-cli"

python-multipart>=0.0.18; extra == "standard-no-fastapi-cloud-cli"

email-validator>=2.0.0; extra == "standard-no-fastapi-cloud-cli"

uvicorn[standard]>=0.12.0; extra == "standard-no-fastapi-cloud-cli"

pydantic-settings>=2.0.0; extra == "standard-no-fastapi-cloud-cli"

pydantic-extra-types>=2.0.0; extra == "standard-no-fastapi-cloud-cli"

fastapi-cli[standard]>=0.0.32; extra == "all"

python-multipart>=0.0.18; extra == "all"

uvicorn[standard]>=0.12.0; extra == "all"

pydantic-settings>=2.0.0; extra == "all"

pydantic-extra-types>=2.0.0; extra == "all"

Intended Audience :: System Administrators

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

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


Summary: Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed.

Tornado Web Server
==================

.. image:: https://badges.gitter.im/Join%20Chat.svg
   :alt: Join the chat at https://gitter.im/tornadoweb/tornado
   :target: https://gitter.im/tornadoweb/tornado?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge

`Tornado <http://www.tornadoweb.org>`_ is a Python web framework and
asynchronous networking library, originally developed at `FriendFeed
<http://friendfeed.com>`_.  By using non-blocking network I/O, Tornado
can scale to tens of thousands of open connections, making it ideal for
`long polling <http://en.wikipedia.org/wiki/Push_technology#Long_Polling>`_,
`WebSockets <http://en.wikipedia.org/wiki/WebSocket>`_, and other
applications that require a long-lived connection to each user.

Hello, world
------------

Here is a simple "Hello, world" example web app for Tornado:

.. code-block:: python

    import asyncio
    import tornado

    class MainHandler(tornado.web.RequestHandler):
        def get(self):
            self.write("Hello, world")

    def make_app():
        return tornado.web.Application([
            (r"/", MainHandler),
        ])

    async def main():
        app = make_app()
        app.listen(8888)
        await asyncio.Event().wait()

    if __name__ == "__main__":
        asyncio.run(main())

This example does not use any of Tornado's asynchronous features; for
that see this `simple chat room
<https://github.com/tornadoweb/tornado/tree/stable/demos/chat>`_.

Documentation
-------------

Documentation and links to additional resources are available at
https://www.tornadoweb.org


Summary: A web server and web framework that's written to go fast. Build fast. Run fast.

.. image:: https://raw.githubusercontent.com/sanic-org/sanic-assets/master/png/sanic-framework-logo-400x97.png
    :alt: Sanic | Build fast. Run fast.

Sanic | Build fast. Run fast.
=============================

.. start-badges

.. list-table::
    :widths: 15 85
    :stub-columns: 1

    * - Build
      - | |Tests|
    * - Docs
      - | |UserGuide| |Documentation|
    * - Package
      - | |PyPI| |PyPI version| |Wheel| |Supported implementations| |Code style ruff|
    * - Support
      - | |Forums| |Discord| |Awesome|
    * - Stats
      - | |Monthly Downloads| |Weekly Downloads| |Conda downloads|

.. |UserGuide| image:: https://img.shields.io/badge/user%20guide-sanic-ff0068
   :target: https://sanic.dev/
.. |Forums| image:: https://img.shields.io/badge/forums-community-ff0068.svg
   :target: https://community.sanicframework.org/
.. |Discord| image:: https://img.shields.io/discord/812221182594121728?logo=discord&label=Discord&color=5865F2
   :target: https://discord.gg/FARQzAEMAA
.. |Tests| image:: https://github.com/sanic-org/sanic/actions/workflows/tests.yml/badge.svg?branch=main
   :target: https://github.com/sanic-org/sanic/actions/workflows/tests.yml
.. |Documentation| image:: https://readthedocs.org/projects/sanic/badge/?version=latest
   :target: http://sanic.readthedocs.io/en/latest/?badge=latest
.. |PyPI| image:: https://img.shields.io/pypi/v/sanic.svg
   :target: https://pypi.python.org/pypi/sanic/
.. |PyPI version| image:: https://img.shields.io/pypi/pyversions/sanic.svg
   :target: https://pypi.python.org/pypi/sanic/
.. |Code style ruff| image:: https://img.shields.io/badge/code%20style-ruff-000000.svg
    :target: https://docs.astral.sh/ruff/
.. |Wheel| image:: https://img.shields.io/pypi/wheel/sanic.svg
    :alt: PyPI Wheel
    :target: https://pypi.python.org/pypi/sanic
.. |Supported implementations| image:: https://img.shields.io/pypi/implementation/sanic.svg
    :alt: Supported implementations
    :target: https://pypi.python.org/pypi/sanic
.. |A

types-ujson; (sys_platform != "win32" and implementation_name == "cpython") and extra == "dev"

sphinx_rtd_theme>=0.4.3; extra == "docs"

types-ujson; (sys_platform != "win32" and implementation_name == "cpython") and extra == "all"

uvloop>=0.15.0; sys_platform != "win32" and implementation_name == "cpython"

ujson>=1.35; sys_platform != "win32" and implementation_name == "cpython"

types-ujson; (sys_platform != "win32" and implementation_name == "cpython") and extra == "test"

Development Status :: 4 - Beta
Environment :: Web Environment
License :: OSI Approved :: MIT License
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


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

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

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

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


Summary: The little ASGI library that shines.

  <picture>
    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/Kludex/starlette/main/docs/img/starlette_dark.svg" width="420px">
    <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/Kludex/starlette/main/docs/img/starlette.svg" width="420px">

  </picture>

    ✨ The little ASGI framework that shines. ✨

---

[![Build Status](https://github.com/Kludex/starlette/workflows/Test%20Suite/badge.svg)](https://github.com/Kludex/starlette/actions)
[![Package version](https://badge.fury.io/py/starlette.svg)](https://pypi.python.org/pypi/starlette)
[![Supported Python Version](https://img.shields.io/pypi/pyversions/starlette.svg?color=%2334D058)](https://pypi.org/project/starlette)
[![Discord](https://img.shields.io/discord/1051468649518616576?logo=discord&logoColor=ffffff&color=7389D8&labelColor=6A7EC2)](https://discord.gg/RxKUF5JuHs)

---

**Documentation**: https://starlette.dev

**Source Code**: https://github.com/Kludex/starlette

---

# Starlette

Starlette is a lightweight [ASGI][asgi] framework/toolkit,
which is ideal for building async web services in Python.

It is production-ready, and gives you the following:

* A lightweight, low-complexity HTTP web framework.
* WebSocket support.
* In-process background tasks.
* Startup and shutdown events.
* Test client built on `httpx`.
* CORS, GZip, Static Files, Streaming responses.
* Session and Cookie support.
* 100% test coverage.
* 100% type annotated codebase.
* Few hard dependencies.
* Compatible with `asyncio` and `trio` backends.
* Great overall performance [against independent benchmarks][techempower].

## Installation

```shell
$ pip install starlette

typing-extensions>=4.10.0; python_version < "3.13"

python-multipart>=0.0.18; extra == "full"

Development Status :: 3 - Alpha
Environment :: Web Environment
Framework :: AnyIO
Intended Audience :: Developers
Operating System :: OS Independent
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
Topic :: Internet :: WWW/HTTP


Summary: The Pyramid Web Framework, a Pylons project

Pyramid
=======

.. image:: https://github.com/Pylons/Pyramid/actions/workflows/ci-tests.yml/badge.svg?branch=2.1-branch
        :target: https://github.com/Pylons/Pyramid/actions/workflows/ci-tests.yml
        :alt: 2.1-branch CI Status

.. image:: https://readthedocs.org/projects/pyramid/badge/?version=2.1-branch
        :target: https://docs.pylonsproject.org/projects/pyramid/en/2.1-branch
        :alt: main Documentation Status

.. image:: https://img.shields.io/discord/1212201651218153582?label=Discord
        :target: https://trypyramid.com/discord-invite.html
        :alt: Discord Server

.. image:: https://img.shields.io/badge/IRC-Libera.Chat-blue.svg
        :target: https://web.libera.chat/#pyramid
        :alt: IRC Libera.Chat

Pyramid is a small, fast, down-to-earth, open source Python web framework.
It makes real-world web application development
and deployment more fun, more predictable, and more productive.
`Try Pyramid <https://trypyramid.com/>`_, browse its add-ons and documentation, and get an overview.

.. code-block:: python

    from wsgiref.simple_server import make_server
    from pyramid.config import Configurator
    from pyramid.response import Response

    def hello_world(request):
        return Response('Hello World!')

    if __name__ == '__main__':
        with Configurator() as config:
            config.add_route('hello', '/')
            config.add_view(hello_world, route_name='hello')
            app = config.make_wsgi_app()
        server = make_server('0.0.0.0', 6543, app)
        server.serve_forever()

Pyramid is a project of the `Pylons Project <https://pylonsproject.org>`_.

Support and Documentation
-------------------------

See `Pyramid Support and Development
<https://docs.pylonsproject.org/projects/pyramid/en/latest/#support-and-development>`_
for documentation, reporting bugs, and getting support.

Developing and Contributing
---------------------------

See `HACKING.txt <https://github.com/Pylons/pyramid/blob/main/HAC

"Chris McDonough, Agendaless Consulting" <pylons-discuss@googlegroups.com>

Programming Language :: Python :: Implementation :: CPython

Programming Language :: Python :: Implementation :: PyPy


Summary: The ultra-reliable, fast ASGI+WSGI framework for building data plane APIs at scale.

.. image:: https://raw.githubusercontent.com/falconry/falcon/master/logo/banner.jpg
   :align: center
   :alt: Falcon logo
   :target: https://falconframework.org/
   :width: 100 %

|Build status| |Docs| |codecov.io| |PyPI package| |Python versions|

The Falcon Web Framework
========================

`Falcon <https://falconframework.org>`__ is a minimalist ASGI/WSGI framework for
building mission-critical REST APIs and microservices, with a focus on
reliability, correctness, and performance at scale.

When it comes to building HTTP APIs, other frameworks weigh you down with tons
of dependencies and unnecessary abstractions. Falcon cuts to the chase with a
clean design that embraces HTTP and the REST architectural style.

Falcon apps work with any `WSGI <https://www.python.org/dev/peps/pep-3333/>`_
or `ASGI <https://asgi.readthedocs.io/en/latest/>`_ server, and run like a
champ under CPython 3.9+ and PyPy 3.9+.

Quick Links
-----------

* `Read the docs <https://falcon.readthedocs.io/en/stable>`_
  (`FAQ <https://falcon.readthedocs.io/en/stable/user/faq.html>`_ -
  `getting help <https://falcon.readthedocs.io/en/stable/community/help.html>`_ -
  `reference <https://falcon.readthedocs.io/en/stable/api/index.html>`_)
* `Falcon add-ons and complementary packages <https://github.com/falconry/falcon/wiki>`_
* `Falcon articles, talks and podcasts <https://github.com/falconry/falcon/wiki/Articles,-Talks-and-Podcasts>`_
* `falconry/user for Falcon users <https://gitter.im/falconry/user>`_ @ Gitter
* `falconry/dev for Falcon contributors <https://gitter.im/falconry/dev>`_ @ Gitter

What People are Saying
----------------------

"Falcon is rock solid and it's fast."

"We have been using Falcon as a replacement for [another framework] and
we simply love the performance (three times faster) and code base size (easily
half of our [original] code)."

"I'm loving #falconframework! Super clean and simple, I finally
have the speed and flexibility I need!"

"Falcon looks great so far.

Development Status :: 5 - Production/Stable

Operating System :: Microsoft :: Windows

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

asgi, wsgi, web, api, framework, rest, http, cloud


Summary: Async http client/server framework (asyncio)

==================================
Async http client/server framework
==================================

.. image:: https://raw.githubusercontent.com/aio-libs/aiohttp/master/docs/aiohttp-plain.svg
   :height: 64px
   :width: 64px
   :alt: aiohttp logo

|

.. image:: https://github.com/aio-libs/aiohttp/workflows/CI/badge.svg
   :target: https://github.com/aio-libs/aiohttp/actions?query=workflow%3ACI
   :alt: GitHub Actions status for master branch

.. image:: https://codecov.io/gh/aio-libs/aiohttp/branch/master/graph/badge.svg
   :target: https://codecov.io/gh/aio-libs/aiohttp
   :alt: codecov.io status for master branch

.. image:: https://badge.fury.io/py/aiohttp.svg
   :target: https://pypi.org/project/aiohttp
   :alt: Latest PyPI package version

.. image:: https://img.shields.io/pypi/dm/aiohttp
   :target: https://pypistats.org/packages/aiohttp
   :alt: Downloads count

.. image:: https://readthedocs.org/projects/aiohttp/badge/?version=latest
   :target: https://docs.aiohttp.org/
   :alt: Latest Read The Docs

.. image:: https://img.shields.io/endpoint?url=https://codspeed.io/badge.json
   :target: https://codspeed.io/aio-libs/aiohttp
   :alt: Codspeed.io status for aiohttp

Key Features
============

- Supports both client and server side of HTTP protocol.
- Supports both client and server Web-Sockets out-of-the-box and avoids
  Callback Hell.
- Provides Web-server with middleware and pluggable routing.

Getting started
===============

Client
------

To get something from the web:

.. code-block:: python

  import aiohttp
  import asyncio

  async def main():

      async with aiohttp.ClientSession() as session:
          async with session.get('https://python.org') as response:

              print("Status:", response.status)
              print("Content-type:", response.headers['content-type'])

              html = await response.text()
              print("Body:", html[:15], "...")

  asyncio.run(main())

This prints:

.. code-block::

    Status: 200

async-timeout<6.0,>=4.0; python_version < "3.11"

typing_extensions>=4.4; python_version < "3.13"

aiodns>=3.3.0; (sys_platform != "android" and sys_platform != "ios") and extra == "speedups"

Brotli>=1.2; (platform_python_implementation == "CPython" and sys_platform != "android" and sys_platform != "ios") and extra == "speedups"

brotlicffi>=1.2; platform_python_implementation != "CPython" and extra == "speedups"

backports.zstd; (platform_python_implementation == "CPython" and python_version < "3.14" and sys_platform != "android" and sys_platform != "ios") and extra == "speedups"


Summary: Fundamental package for array computing in Python

[![Powered by NumFOCUS](https://img.shields.io/badge/powered%20by-NumFOCUS-orange.svg?style=flat&colorA=E1523D&colorB=007D8A)](
https://numfocus.org)
[![PyPI Downloads](https://img.shields.io/pypi/dm/numpy.svg?label=PyPI%20downloads)](
https://pypi.org/project/numpy/)
[![Conda Downloads](https://img.shields.io/conda/dn/conda-forge/numpy.svg?label=Conda%20downloads)](
https://anaconda.org/conda-forge/numpy)
[![Stack Overflow](https://img.shields.io/badge/stackoverflow-Ask%20questions-blue.svg)](
https://stackoverflow.com/questions/tagged/numpy)
[![Nature Paper](https://img.shields.io/badge/DOI-10.1038%2Fs41586--020--2649--2-blue)](
https://doi.org/10.1038/s41586-020-2649-2)
[![LFX Health Score](https://insights.linuxfoundation.org/api/badge/health-score?project=numpy)](https://insights.linuxfoundation.org/project/numpy)
[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/numpy/numpy/badge)](https://securityscorecards.dev/viewer/?uri=github.com/numpy/numpy)
[![Typing](https://img.shields.io/pypi/types/numpy)](https://pypi.org/project/numpy/)

NumPy is the fundamental package for scientific computing with Python.

- **Website:** https://numpy.org
- **Documentation:** https://numpy.org/doc
- **Mailing list:** https://mail.python.org/mailman/listinfo/numpy-discussion
- **Source code:** https://github.com/numpy/numpy
- **Contributing:** https://numpy.org/devdocs/dev/index.html
- **Bug reports:** https://github.com/numpy/numpy/issues
- **Report a security vulnerability:** https://github.com/numpy/numpy/security/policy (via Tidelift)

It provides:

- a powerful N-dimensional array object
- sophisticated (broadcasting) functions
- tools for integrating C/C++ and Fortran code
- useful linear algebra, Fourier transform, and random number capabilities

Testing:

NumPy requires `pytest` and `hypothesis`.  Tests c

BSD-3-Clause AND 0BSD AND MIT AND Zlib AND CC0-1.0

Programming Language :: Python :: 3 :: Only