Summary: ANSI color formatting for output in terminal

# termcolor

[![PyPI version](https://img.shields.io/pypi/v/termcolor.svg?logo=pypi&logoColor=FFE873)](https://pypi.org/project/termcolor)
[![Supported Python versions](https://img.shields.io/pypi/pyversions/termcolor.svg?logo=python&logoColor=FFE873)](https://pypi.org/project/termcolor)
[![PyPI downloads](https://img.shields.io/pypi/dm/termcolor.svg)](https://pypistats.org/packages/termcolor)
[![GitHub Actions status](https://github.com/termcolor/termcolor/workflows/Test/badge.svg)](https://github.com/termcolor/termcolor/actions)
[![Codecov](https://codecov.io/gh/termcolor/termcolor/branch/main/graph/badge.svg)](https://codecov.io/gh/termcolor/termcolor)
[![Licence](https://img.shields.io/github/license/termcolor/termcolor.svg)](COPYING.txt)
[![Code style: Black](https://img.shields.io/badge/code%20style-Black-000000.svg)](https://github.com/psf/black)
[![Tidelift](https://tidelift.com/badges/package/pypi/termcolor)](https://tidelift.com/subscription/pkg/pypi-termcolor?utm_source=pypi-termcolor&utm_medium=referral&utm_campaign=readme)

## Installation

### From PyPI

```bash
python3 -m pip install --upgrade termcolor
```

### From source

```bash
git clone https://github.com/termcolor/termcolor
cd termcolor
python3 -m pip install .
```

### Demo

To see demo output, run:

```bash
python3 -m termcolor
```

## Example

```python
import sys

from termcolor import colored, cprint

text = colored("Hello, World!", "red", attrs=["reverse", "blink"])
print(text)
cprint("Hello, World!", "green", "on_red")

print_red_on_cyan = lambda x: cprint(x, "red", "on_cyan")
print_red_on_cyan("Hello, World!")
print_red_on_cyan("Hello, Universe!")

for i in range(10):
    cprint(i, "magenta", end=" ")

cprint("Attention!", "red", attrs=["bold"], file=sys.stderr)

# You can also specify 0-255 RGB ints via a tuple
cprint("Both foreground and background can use tuples", (100, 150, 250), (50, 60, 70))
```

## Text properties

| Text colors     | Text highlights    | Attributes  |
| --------

pytest; extra == "tests"
pytest-cov; extra == "tests"

ANSI, ANSI color, ANSI colour, color, colour, formatting, termcolor, terminal


Summary: Python package for providing Mozilla's CA Bundle.

Certifi: Python SSL Certificates
================================

Certifi provides Mozilla's carefully curated collection of Root Certificates for
validating the trustworthiness of SSL certificates while verifying the identity
of TLS hosts. It has been extracted from the `Requests`_ project.

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

``certifi`` is available on PyPI. Simply install it with ``pip``::

    $ pip install certifi

Usage
-----

To reference the installed certificate authority (CA) bundle, you can use the
built-in function::

    >>> import certifi

    >>> certifi.where()
    '/usr/local/lib/python3.7/site-packages/certifi/cacert.pem'

Or from the command line::

    $ python -m certifi
    /usr/local/lib/python3.7/site-packages/certifi/cacert.pem

Enjoy!

.. _`Requests`: https://requests.readthedocs.io/en/latest/

Addition/Removal of Certificates
--------------------------------

Certifi does not support any addition/removal or other modification of the
CA trust store content. This project is intended to provide a reliable and
highly portable root of trust to python deployments. Look to upstream projects
for methods to use alternate trust.

Development Status :: 5 - Production/Stable

License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)

Programming Language :: Python :: 3 :: Only


Summary: Python bindings for Network Security Services (NSS) and Netscape Portable Runtime (NSPR)

python-nss is a Python binding for NSS (Network Security Services) and
NSPR (Netscape Portable Runtime). NSS provides cryptography services
supporting SSL, TLS, PKI, PKIX, X509, PKCS*, etc. NSS is an
alternative to OpenSSL and used extensively by major software
projects. NSS is FIPS-140 certified.

NSS is built upon NSPR because NSPR provides an abstraction of common
operating system services, particularly in the areas of networking and
process management. Python also provides an abstraction of common
operating system services but because NSS and NSPR are tightly bound
python-nss exposes elements of NSPR.

More information on python-nss can be found on the
`python-nss project page <http://www.mozilla.org/projects/security/pki/python-nss>`_

For information on NSS and NSPR, see the following:

    * Network Security Services. `NSS project page <http://www.mozilla.org/projects/security/pki/nss/>`_.
    * Netscape Portable Runtime. `NSPR project page <http://www.mozilla.org/projects/nspr/>`_.

To build python-nss you the C language header files and libraries for
both NSPR and NSS will need to be installed. This is system and
distribution specific, as such we cannot give you explicit
instructions. On Linux typically these packages are called:

    * nss-devel
    * nspr-devel

Use your system package manger to install them, for example on Fedora:

    % sudo yum install nss-devel nspr-devel

After all packages are installed, then:

    % python setup.py build
    % sudo python setup.py install

To generate the API documentation:

    % python setup.py build_doc


[![PyPI version](https://badge.fury.io/py/pycert.svg)](https://badge.fury.io/py/pycert)
[![Build Status](https://app.travis-ci.com/c-pher/certificate.svg?branch=master)](https://app.travis-ci.com/c-pher/certificate)

# Certificate

The cross-platform tool to get certificate info (including self-signed).

## Installation

For most users, the recommended method to install is via pip:

```cmd
pip install pycert
```

## Import

```python
from pycert import CertClient
```

---

## Usage

#### Command from usual user:

```python
from pycert import CertClient

client = CertClient(host="172.16.0.124")
print(client.get_all_info())

```

```python
from pprint import pprint
from pycert import CertClient

cert = CertClient('pypi.org')

pprint(cert.get_all_info())

```

```json
{
  "version": "v3",
  "valid_from": "2021-10-22T18:41:11",
  "valid_to": "2022-11-23T18:41:10",
  "is_valid": true,
  "is_self_signed": false,
  "issuer": {
    "C": "BE",
    "O": "GlobalSign nv-sa",
    "CN": "GlobalSign Atlas R3 DV TLS CA H2 2021"
  },
  "subject": {
    "CN": "www.python.org"
  },
  "signature_algorithm": "sha256",
  "serial_number": "1B7C6CD03E8E071BE48C2B1A7994075",
  "alternative_name": [
    "DNS:www.python.org",
    "DNS:*.python.org",
    "DNS:docs.python.org",
    "DNS:downloads.python.org",
    "DNS:pypi.python.org"
  ],
  "fingerprint": "CE1F8748D2DA0265B329F1DFD70047DCEF6CD8FB"
}
```

## Useful links

- [RFC3280](https://datatracker.ietf.org/doc/html/rfc3280)
- [OpenSSL cheatsheet](https://megamorf.gitlab.io/cheat-sheets/openssl/)

## Changelog:

##### unreleased

##### 1.0.3 (4.06.2022)

- Log name changed to `CertClient`
- Log format changed according other modules

##### 1.0.2 (17.04.2022)

- External logger added

##### 1.0.1 (14.12.2021)

- refactored "get_all_info": not it gets issuer and subject dynamically
- get_serial_number: returns upper hexadecimal without first bit now
- is_self_signed: preliminary method added (can be changed in future)
- get_all_methods fixed

pyOpenSSL (>=21.0.0)
python-dateutil (~=2.8.2)
plogger (>=1.0.6)

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


Summary: Robust log handling specialized for logging in the Mozilla universe

see https://firefox-source-docs.mozilla.org/mozbase/index.html

blessed>=1.19.1 mozterm mozfile mozsystemmonitor

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


Summary: Library to create and modify Mozilla application profiles


Summary: Mozilla-authored process handling


Summary: Mozilla-authored device management

Programming Language :: Python :: 3.10
Programming Language :: Python :: 3.11
Programming Language :: Python :: 3.8
Programming Language :: Python :: 3.9


Summary: Reliable start/stop/configuration of Mozilla Applications (Firefox, Thunderbird, etc.)


Summary: Python bindings for the Qt cross-platform application and UI framework

# PySide2

### Introduction

PySide2 is the official Python module from the
[Qt for Python project](http://wiki.qt.io/Qt_for_Python),
which provides access to the complete Qt 5.12+ framework.

The Qt for Python project is developed in the open, with all facilities you'd expect
from any modern OSS project such as all code in a git repository and an open
design process. We welcome any contribution conforming to the
[Qt Contribution Agreement](https://www.qt.io/contributionagreement/).

### Installation

Since the release of the [Technical Preview](https://blog.qt.io/blog/2018/06/13/qt-python-5-11-released/)
it is possible to install via `pip`, both from Qt's servers
and [PyPi](https://pypi.org/project/PySide2/):

    pip install PySide2

#### Dependencies

PySide2 versions following 5.12 use a C++ parser based on
[Clang](http://clang.org/). The Clang library (C-bindings), version 6.0 or
higher is required for building. Prebuilt versions of it can be downloaded from
[download.qt.io](http://download.qt.io/development_releases/prebuilt/libclang/).

After unpacking the archive, set the environment variable *LLVM_INSTALL_DIR* to
point to the folder containing the *include* and *lib* directories of Clang:

    7z x .../libclang-release_60-linux-Rhel7.2-gcc5.3-x86_64-clazy.7z
    export LLVM_INSTALL_DIR=$PWD/libclang

On Windows:

    7z x .../libclang-release_60-windows-vs2015_64-clazy.7z
    SET LLVM_INSTALL_DIR=%CD%\libclang

### Building from source

For building PySide2 from scratch, please read about
[getting started](https://wiki.qt.io/Qt_for_Python/GettingStarted).
This process will include getting the code:

    git clone https://code.qt.io/pyside/pyside-setup
    cd pyside-setup
    git branch --track 5.12 origin/5.12
    git checkout 5.12

then install the dependencies, and following the instructions per platform.
A common build command will look like:

    python setup.py install --qmake=<path/to/qmake/> --parallel=8 --build-tests

You can obtain more information

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

Operating System :: Microsoft :: Windows

Topic :: Software Development :: Code Generators

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

Topic :: Software Development :: User Interfaces

Topic :: Software Development :: Widget Sets


# PySide6

### Introduction

**Important:** for Qt5 compatibility, check [PySide2](https://pypi.org/project/PySide2)

PySide6 is the official Python module from the
[Qt for Python project](https://wiki.qt.io/Qt_for_Python),
which provides access to the complete Qt 6.0+ framework.

The Qt for Python project is developed in the open, with all facilities you'd expect
from any modern OSS project such as all code in a git repository and an open
design process. We welcome any contribution conforming to the
[Qt Contribution Agreement](https://www.qt.io/contributionagreement/).

### Installation

Since the release of the [Technical Preview](https://blog.qt.io/blog/2018/06/13/qt-python-5-11-released/)
it is possible to install via `pip`, both from Qt's servers
and [PyPi](https://pypi.org/project/PySide6/):

```
pip install PySide6
```

> Please note: this wheel is an alias to other two wheels
> [PySide6_Essentials](https://pypi.org/project/PySide6_Essentials) and
> [PySide6_Addons](https://pypi.org/project/PySide6_Addons), which contains
> a predefined list of Qt Modules.

#### Dependencies

PySide6 versions following 6.0 use a C++ parser based on
[Clang](http://clang.org/). The Clang library (C-bindings), version 13.0 or
higher is required for building. Prebuilt versions of it can be downloaded from
[download.qt.io](https://download.qt.io/development_releases/prebuilt/libclang/).

After unpacking the archive, set the environment variable *LLVM_INSTALL_DIR* to
point to the folder containing the *include* and *lib* directories of Clang:

```
7z x .../libclang-release_100-linux-Rhel7.2-gcc5.3-x86_64-clazy.7z
export LLVM_INSTALL_DIR=$PWD/libclang
```

On Windows:

```
7z x .../libclang-release_100-windows-vs2015_64-clazy.7z
SET LLVM_INSTALL_DIR=%CD%\libclang
```

### Building from source

For building PySide6 from scratch, please read about
[getting started](https://doc.qt.io/qtforpython/gettingstarted.html).
This process will include getting the code:

```
git clone https://co

Qt for Python Team <pyside@qt-project.org>

LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only


Summary: Python interface for cairo

.. image:: https://raw.githubusercontent.com/pygobject/pycairo/main/docs/images/pycairo.svg
   :align: center
   :width: 370px

|

Pycairo is a Python module providing bindings for the `cairo graphics library
<https://cairographics.org/>`__. It depends on **cairo >= 1.15.10** and works
with **Python 3.10+** and **PyPy3**. Pycairo, including this documentation, is
licensed under the `LGPL-2.1-only OR MPL-1.1 <https://spdx.dev/ids>`__.

The Pycairo bindings are designed to match the cairo C API as closely as
possible, and to deviate only in cases which are clearly better implemented in
a more ‘Pythonic’ way.

.. code:: shell

    pip install pycairo

Installing Pycairo requires cairo including its headers. For more info see
"`Getting Started
<https://pycairo.readthedocs.io/en/latest/getting_started.html>`__".

----

.. code:: python

    import cairo

    with cairo.SVGSurface("example.svg", 200, 200) as surface:
        context = cairo.Context(surface)
        x, y, x1, y1 = 0.1, 0.5, 0.4, 0.9
        x2, y2, x3, y3 = 0.6, 0.1, 0.9, 0.5
        context.scale(200, 200)
        context.set_line_width(0.04)
        context.move_to(x, y)
        context.curve_to(x1, y1, x2, y2, x3, y3)
        context.stroke()
        context.set_source_rgba(1, 0.2, 0.2, 0.6)
        context.set_line_width(0.02)
        context.move_to(x, y)
        context.line_to(x1, y1)
        context.move_to(x2, y2)
        context.line_to(x3, y3)
        context.stroke()

.. image:: https://raw.githubusercontent.com/pygobject/pycairo/main/docs/images/example.svg
    :width: 320px
    :align: center

----

Features of the Pycairo bindings:

* Provides an object oriented interface to cairo.
* Queries the error status of objects and translates them to exceptions.
* Provides a C API that can be used by other Python extensions.
* Fully typed and documented API.

For more information visit https://pycairo.readthedocs.io


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 psycopg

Programming Language :: Python :: Implementation :: CPython


Summary: Python bindings for libcups

This is a set of Python bindings for the libcups library from the
CUPS project.

>>> # Example of getting a list of printers
>>> import cups
>>> conn = cups.Connection ()
>>> printers = conn.getPrinters ()
>>> for printer in printers:
    ...     print printer, printers[printer]["device-uri"]
...
HP ipp://192.168.1.1:631/printers/HP
duplex ipp://192.168.1.1:631/printers/duplex
HP-LaserJet-6MP ipp://192.168.1.1:631/printers/HP-LaserJet-6MP
EPSON-Stylus-D78 usb://EPSON/Stylus%20D78

License :: OSI Approved :: GNU General Public License (GPL)


Summary: VLC bindings for python.

Python ctypes-based bindings for libvlc
=======================================

The bindings use ctypes to directly call the libvlc dynamic lib, and
the code is generated from the include files defining the public
API. The same module should be compatible with various versions of
libvlc 3.*. However, there may be incompatible changes between major
versions.

Installing the module
---------------------

You can install the module through PyPI:

    pip install python-vlc

Using the module
----------------

The module offers two ways of accessing the API - a raw access to all
exported methods, and more convenient wrapper classes.

Using wrapper classes
+++++++++++++++++++++

Most major structures of the libvlc API (Instance, Media, MediaPlayer,
etc) are wrapped as classes, with shorter method names and some
adaptations to provide a more pythonic API:

    >>> import vlc
    >>> player = vlc.MediaPlayer('file:///tmp/foo.avi')
    >>> player.play()
    >>> player.get_instance() # returns the corresponding instance

In this case, a default ``vlc.Instance`` will be instanciated and
stored in ``vlc._default_instance``. It will be used to instanciate
the various classes (``Media``, ``MediaList``, ``MediaPlayer``, etc).

You also can use wrapper methods closer to the original libvlc API:

    >>> import vlc
    >>> instance = vlc.Instance('--no-audio', '--fullscreen')
    >>> player = instance.media_player_new()
    >>> player.audio_get_volume()
    50
    >>> media = instance.media_new('file:///tmp/foo.avi')
    >>> media.get_mrl()
    'file:///tmp/foo.avi'
    >>> player.set_media(m)
    >>> player.play()

Using raw access
++++++++++++++++

Libvlc methods are available as attributes of the vlc module (as
  vlc.libvlc_*). Use their docstring (any introspective shell like
  ipython is your friend) to explore them, or refer to the online
  documentation at https://olivieraubert.net/vlc/python-ctypes/

    >>> import vlc
    >>> vlc.libvlc_get_version()
    '3.0.0-rc2 Vetinar

License :: OSI Approved :: GNU Lesser General Public License v2 or later (LGPLv2+)


Summary: The libvirt virtualization API python binding

Libvirt Python Binding README
=============================

This package provides a module that permits applications
written in the Python 3.x programming language to call the interface
supplied by the libvirt library, to manage the virtualization
capabilities of recent versions of Linux (and other OSes).
As such, the module exposes Python bindings to to the libvirt.so,
libvirt-qemu.so and libvirt-lxc.so library APIs.

It is written to build against any version of libvirt that
is 0.9.11 or newer.

This code is distributed under the terms of the LGPL version
2 or later.

Requirements
------------

To build the libvirt python binary requires the GCC and pkg-config
tools, and development headers for the libvirt and python libraries.

Additionally, the Python build module is required and can be installed via:

  $ dnf install python3-build

or

  $ python3 -m pip install --user build

Building and installing
-----------------------

The module can be built by following the normal python module
build process

  $ python3 -m build

for testing and distributing purposes or it can be installed directly via pip
as

  $ python3 -m pip install .

without explicit building.

In order to test the package, you'll need either tox or at least pytest,
depending on whether you want to test an already installed package in which
case the latter is sufficient or if you wish to test in a virtual
environment you'd need tox.

To install pytest, use one of:

  $ dnf install python3-pytest

or

  $ python3 -m pip install --user pytest

To install tox, use one of:

  $ dnf install python3-tox

or

  $ python3 -m pip install --user tox

Additionally, install the remaining test dependencies:

  $ python3 -m pip install -r requirements-test.txt

Depending on your preferred setup, you can run the tests either as

  $ python3 -m pytest

or as

  $ tox

Free-threaded Python (py313t, py314t) test environments require tox>=4.26
and the corresponding free-threaded interpreters (python3.13t, python3.1


Summary: Python interface to Graphviz

PyGraphviz
==========

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

.. image:: https://codecov.io/gh/pygraphviz/pygraphviz/branch/main/graph/badge.svg
   :target: https://app.codecov.io/gh/pygraphviz/pygraphviz/branch/main

PyGraphviz is a Python interface to the Graphviz graph layout and
visualization package.
With PyGraphviz you can create, edit, read, write, and draw graphs using
Python to access the Graphviz graph data structure and layout algorithms.
PyGraphviz provides a similar programming interface to NetworkX
(https://networkx.org).

- **Website (including documentation):** https://pygraphviz.github.io
- **Mailing list:** https://groups.google.com/forum/#!forum/pygraphviz-discuss
- **Source:** https://github.com/pygraphviz/pygraphviz
- **Bug reports:** https://github.com/pygraphviz/pygraphviz/issues

Simple example
--------------

.. code:: pycon

    >>> import pygraphviz as pgv
    >>> G = pgv.AGraph()
    >>> G.add_node("a")
    >>> G.add_edge("b", "c")
    >>> print(G)
    strict graph "" {
            a;
            b -- c;
    }

Install
-------

PyGraphviz requires Graphviz.
Please see `INSTALL.txt` for details.

License
-------

Released under the 3-Clause BSD license (see ``LICENSE``)::

  Copyright (C) 2006-2026 PyGraphviz Developers
  Aric Hagberg <aric.hagberg@gmail.gov>
  Dan Schult <dschult@colgate.edu>
  Manos Renieris

The binary wheels distributed on PyPI bundle the Graphviz libraries and
command-line tools, which are licensed separately under the Eclipse Public
License v2.0 (see ``LICENSE.graphviz``).

Aric Hagberg <aric.hagberg@gmail.com>, Dan Schult <dschult@colgate.edu>

Programming Language :: Python :: Implementation :: PyPy

Topic :: Scientific/Engineering :: Information Analysis

Topic :: Scientific/Engineering :: Mathematics

Topic :: Scientific/Engineering :: Visualization

Networks, Graph Visualization, network, graph, graph drawing


PycURL -- A Python Interface To The cURL library
================================================

PycURL is a Python interface to `libcurl`_, the multiprotocol file
transfer library. Similarly to the urllib_ Python module,
PycURL can be used to fetch objects identified by a URL from a Python program.
Beyond simple fetches however PycURL exposes most of the functionality of
libcurl, including:

- Speed - libcurl is very fast and PycURL, being a thin wrapper above
  libcurl, is very fast as well. PycURL `was benchmarked`_ to be several
  times faster than requests_.
- Features including multiple protocol support, SSL, authentication and
  proxy options. PycURL supports most of libcurl's callbacks.
- Multi_ and share_ interfaces.
- Sockets used for network operations, permitting integration of PycURL
  into the application's I/O loop (e.g., using Tornado_).

.. _was benchmarked: http://stackoverflow.com/questions/15461995/python-requests-vs-pycurl-performance
.. _requests: http://python-requests.org/
.. _Multi: https://curl.haxx.se/libcurl/c/libcurl-multi.html
.. _share: https://curl.haxx.se/libcurl/c/libcurl-share.html
.. _Tornado: http://www.tornadoweb.org/

Requirements
------------

- Python 3.10-3.14.
- libcurl 7.19.0 or better.

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

Download the source distribution from `PyPI`_.

Please see `the installation documentation`_ for installation instructions.

.. _PyPI: https://pypi.python.org/pypi/pycurl
.. _the installation documentation: http://pycurl.io/docs/latest/install.html

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

Documentation for the most recent PycURL release is available on
`PycURL website <http://pycurl.io/docs/latest/>`_.

Support
-------

For support questions please use `curl-and-python mailing list`_.
`Mailing list archives`_ are available for your perusal as well.

Although not an official support venue, `Stack Overflow`_ has been
popular with some PycURL users.

Bugs can be reported `via GitHub`_. Please use GitHub only for bug
repo

Kjetil Jacobsen <kjetilja@gmail.com>, "Markus F.X.J. Oberhumer" <markus@oberhumer.com>, Oleg Pudeyev <oleg@bsdpower.com>

Development Status :: 5 - Production/Stable

Programming Language :: Python :: Free Threading :: 1 - Unstable

Topic :: Internet :: File Transfer Protocol (FTP)

curl, libcurl, urllib, wget, download, file transfer, http, www


Summary: GDAL: Geospatial Data Abstraction Library

GDAL/OGR in Python
==================

This Python package and extensions are a number of tools for programming and
manipulating the GDAL_ Geospatial Data Abstraction Library.
Generally speaking the classes and methods mostly
match those of the GDAL and OGR C++ classes.

A basic starting point is the `Vector API Tutorial <https://gdal.org/tutorials/vector_api_tut.html>`__.
For full documentation, see the `GDAL Python API <https://gdal.org/api/python/index.html>`__.

The GDAL Python package is built using `SWIG <https://www.swig.org>`__.
The GDAL project maintains these Python bindings for GDAL/OGR within
the gdal source tree.
The SWIG-generated files are not checked in and are not part of the
gdal release tarballs.  The bindings are also made available via PyPi
where the swig-generated files are provided.

Building from source
--------------------

To build from source, there are multiple possible paths.

Dependencies
~~~~~~~~~~~~

(As usual, when a package is listed one needs the parts used to build
programs against it, called -devel on many systems.  This is not
special about gdal.)

 * SWIG (4 or greater).

 * libgdal (3.13.2 or greater).

 * numpy (1.0.0 or greater).  This is not force-required by the build,
   but many examples and utilities will not work without it.  At least
   osgeo.gdal_array requires numpy at build time; building without
   numpy and installing it later does not result in correct operation.
   apparently not and in any case it is an unwarranted leap.

 * setuptools (python)

 * wheel (python)

Building when building the rest of GDAL
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Python bindings are generated by default when building GDAL from source.
For more detail, see `Python bindings options <https://gdal.org/development/building_from_source.html#building-python-bindings>`__

Building just the bindings, from the full tree
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Another is to use the gdal source distribution with an
already-installed

Frank Warmerdam, Howard Butler, Even Rouault


Summary: Python bindings for the Qt cross platform application toolkit

# PyQt5 - Comprehensive Python Bindings for Qt v5

Qt is set of cross-platform C++ libraries that implement high-level APIs for
accessing many aspects of modern desktop and mobile systems.  These include
location and positioning services, multimedia, NFC and Bluetooth connectivity,
a Chromium based web browser, as well as traditional UI development.

PyQt5 is a comprehensive set of Python bindings for Qt v5.  It is implemented
as more than 35 extension modules and enables Python to be used as an
alternative application development language to C++ on all supported platforms
including iOS and Android.

PyQt5 may also be embedded in C++ based applications to allow users of those
applications to configure or enhance the functionality of those applications.

## Author

PyQt5 is copyright (c) Riverbank Computing Limited.  Its homepage is
https://www.riverbankcomputing.com/software/pyqt/.

Support may be obtained from the PyQt mailing list at
https://www.riverbankcomputing.com/mailman/listinfo/pyqt/.

## License

PyQt5 is released under the GPL v3 license and under a commercial license that
allows for the development of proprietary applications.

## Documentation

The documentation for the latest release can be found
[here](https://www.riverbankcomputing.com/static/Docs/PyQt5/).

## Installation

The GPL version of PyQt5 can be installed from PyPI:

    pip install PyQt5

`pip` will also build and install the bindings from the sdist package but Qt's
`qmake` tool must be on `PATH`.

The `sip-install` tool will also install the bindings from the sdist package
but will allow you to configure many aspects of the installation.

Riverbank Computing Limited <info@riverbankcomputing.com>


# PyQt6 - Comprehensive Python Bindings for Qt v6

Qt is set of cross-platform C++ libraries that implement high-level APIs for
accessing many aspects of modern desktop and mobile systems.  These include
location and positioning services, multimedia, NFC and Bluetooth connectivity,
a Chromium based web browser, as well as traditional UI development.

PyQt6 is a comprehensive set of Python bindings for Qt v6.  It is implemented
as more than 35 extension modules and enables Python to be used as an
alternative application development language to C++ on all supported platforms
including iOS and Android.

PyQt6 may also be embedded in C++ based applications to allow users of those
applications to configure or enhance the functionality of those applications.

## Author

PyQt6 is copyright (c) Riverbank Computing Limited.  Its homepage is
https://www.riverbankcomputing.com/software/pyqt/.

Support may be obtained from the PyQt mailing list at
https://www.riverbankcomputing.com/mailman/listinfo/pyqt/.

## License

PyQt6 is released under the GPL v3 license and under a commercial license that
allows for the development of proprietary applications.

## Documentation

The documentation for the latest release can be found
[here](https://www.riverbankcomputing.com/static/Docs/PyQt6/).

## Installation

The GPL version of PyQt6 can be installed from PyPI:

    pip install PyQt6

`pip` will also build and install the bindings from the sdist package but Qt's
`qmake` tool must be on `PATH`.

The `sip-install` tool will also install the bindings from the sdist package
but will allow you to configure many aspects of the installation.


Summary: Radically simple IT automation

..
  GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
  SPDX-License-Identifier: GPL-3.0-or-later
  SPDX-FileCopyrightText: Ansible Project, 2020

|PyPI version| |Docs badge| |Chat badge| |Code Of Conduct| |Forum| |License|

*******
Ansible
*******

Ansible is a radically simple IT automation system. It handles configuration management, application
deployment, cloud provisioning, ad-hoc task execution, network automation, and multi-node
orchestration. Ansible makes complex changes like zero-downtime rolling updates with load balancers
easy. More information on the Ansible `website <https://ansible.com/>`_.

This is the ``ansible`` community package.
The ``ansible`` python package contains a set of
independent Ansible collections that are curated by the community,
and it pulls in `ansible-core <https://pypi.org/project/ansible-core/>`_.
The ``ansible-core`` python package contains the core runtime and CLI tools,
such as ``ansible`` and ``ansible-playbook``,
while the ``ansible`` package contains extra modules, plugins, and roles.

``ansible`` follows `semantic versioning <https://semver.org/>`_.
Each major version of ``ansible`` depends on a specific major version of
``ansible-core`` and contains specific major versions of the collections it
includes.

Design Principles
=================

*  Have an extremely simple setup process and a minimal learning curve.
*  Manage machines quickly and in parallel.
*  Avoid custom-agents and additional open ports, be agentless by
   leveraging the existing SSH daemon.
*  Describe infrastructure in a language that is both machine and human
   friendly.
*  Focus on security and easy auditability/review/rewriting of content.
*  Manage new remote machines instantly, without bootstrapping any
   software.
*  Allow module development in any dynamic language, not just Python.
*  Be usable as non-root.
*  Be the easiest IT automation system to use, ever.

Use Ansible
===========

You can install

Intended Audience :: Information Technology

Intended Audience :: System Administrators

Programming Language :: Python :: 3 :: Only


Summary: Fast scalable distributed SCM (revision control, version control) system

Mercurial
=========

Mercurial is a fast, easy to use, distributed revision control tool
for software developers.

Basic install::

 $ make            # see install targets
 $ make install    # do a system-wide install
 $ hg debuginstall # sanity-check setup
 $ hg              # see help

Running without installing::

 $ make local      # build for inplace usage
 $ ./hg-local --version  # should show the latest version

See https://mercurial-scm.org/ for detailed installation
instructions, platform-specific notes, and Mercurial user information.

Notes for packagers
===================

Mercurial ships a copy of the python-zstandard sources. This is used to
provide support for zstd compression and decompression functionality. The
module is not intended to be replaced by the plain python-zstandard nor
is it intended to use a system zstd library. Patches can result in hard
to diagnose errors and are explicitly discouraged as unsupported
configuration.

Olivia Mackall and many others <mercurial@mercurial-scm.org>

Natural Language :: Portuguese (Brazilian)

Operating System :: Microsoft :: Windows

Topic :: Software Development :: Version Control


![Spyder — The Scientific Python Development Environment](https://raw.githubusercontent.com/spyder-ide/spyder/master/branding/logo/spyder_readme_banner.png)

*Copyright © 2009– [Spyder Project Contributors](https://github.com/spyder-ide/spyder/graphs/contributors)* and others (see AUTHORS.txt)

*Some source files and icons may be under other authorship/licenses; see
[NOTICE.txt](https://github.com/spyder-ide/spyder/blob/master/NOTICE.txt).*

## Project status

[![license](https://img.shields.io/pypi/l/spyder.svg)](./LICENSE.txt)
[![pypi version](https://img.shields.io/pypi/v/spyder.svg)](https://pypi.org/project/spyder/)
[![conda version](https://img.shields.io/conda/vn/conda-forge/spyder.svg)](https://anaconda.org/conda-forge/spyder)
[![download count](https://img.shields.io/conda/dn/conda-forge/spyder.svg)](https://anaconda.org/conda-forge/spyder)
[![OpenCollective Backers](https://opencollective.com/spyder/backers/badge.svg?color=blue)](#backers)
[![OpenCollective Sponsors](https://opencollective.com/spyder/sponsors/badge.svg?color=blue)](#sponsors)
[![Join the chat at https://gitter.im/spyder-ide/public](https://badges.gitter.im/spyder-ide/spyder.svg)](https://gitter.im/spyder-ide/public)<br>
[![PyPI status](https://img.shields.io/pypi/status/spyder.svg)](https://github.com/spyder-ide/spyder)

## Build status

[![Win](https://github.com/spyder-ide/spyder/actions/workflows/test-win.yml/badge.svg)](https://github.com/spyder-ide/spyder/actions/workflows/test-win.yml)
[![Mac](https://github.com/spyder-ide/spyder/actions/workflows/test-mac.yml/badge.svg)](https://github.com/spyder-ide/spyder/actions/workflows/test-mac.yml)
[![Linux](https://github.com/spyder-ide/spyder/actions/workflows/test-linux.yml/badge.svg)](https://github.com/spyder-ide/spyder/actions/workflows/test-linux.yml)
[![Coverage Status](https://coveralls.io/repos/github/spyder-ide/spyder/badge.svg?branch=master)](https://coveralls.io/github/spyder-ide/spyder?branch=master)
[![codecov](https://codecov.

applaunchservices>=0.3.0; platform_system == "Darwin"

pywin32; platform_system == "Windows" and extra == "test"

Topic :: Software Development :: Widget Sets

PyQt5 editor console widgets IDE science data analysis IPython


Summary: Advanced probability calibration techniques for machine learning models

# calibre

[![PyPI version](https://img.shields.io/pypi/v/calibre.svg)](https://pypi.org/project/calibre/)
[![Python](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
[![Downloads](https://pepy.tech/badge/calibre)](https://pepy.tech/project/calibre)
[![CI](https://github.com/finite-sample/calibre/workflows/CI/badge.svg)](https://github.com/finite-sample/calibre/actions/workflows/ci.yml)
[![Documentation](https://img.shields.io/badge/docs-stable-green.svg)](https://finite-sample.github.io/calibre/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

**Probability calibration that doesn't flatten your scores.**

Your classifier's probabilities are usually wrong — a model that says "80%" may be
right 60% of the time. Isotonic regression is the standard fix, and it works, but it
pays for accuracy with resolution: it is a step function, so it collapses many
distinct scores into a handful of values.

On a 2,000-point held-out set, isotonic regression turns 2,000 distinct scores into
**56**. Everything inside a step becomes indistinguishable — which matters as soon as
you rank, threshold, or bucket the output.

calibre gives you calibrators that fix the probabilities *and* keep the ordering.

## Install

```bash
pip install calibre
```

Python 3.12+. Depends on numpy, scipy, scikit-learn and cvxpy.

## The problem, in 20 lines

```python
import numpy as np
from sklearn.model_selection import train_test_split

from calibre import CenteredIsotonicCalibrator, IsotonicCalibrator

# An overconfident model: true log-odds z, but the model reports 1.8 * z.
rng = np.random.default_rng(0)
z = rng.normal(0, 2, 4000)
y = (rng.random(4000) < 1 / (1 + np.exp(-z))).astype(float)
scores = 1 / (1 + np.exp(-1.8 * z))

# Always fit the calibrator on data the model did not train on.
s_fit, s_test, y_fit, y_test = train_test_split(
    scores, y, test_size=0.5, random_state=0
)

isotonic = IsotonicC

Topic :: Scientific/Engineering :: Artificial Intelligence


Summary: Gramps (Genealogical Research and Analysis Management Programming System)

[The Gramps Project](https://gramps-project.org)
===================
[![GitHub CI](https://github.com/gramps-project/gramps/actions/workflows/gramps-ci.yml/badge.svg?event=push&branch=maintenance/gramps60)](https://github.com/gramps-project/gramps/actions/workflows/gramps-ci.yml?query=branch%3Amaintenance/gramps60)
[![codecov.io](https://codecov.io/github/gramps-project/gramps/coverage.svg?branch=maintenance/gramps60)](https://app.codecov.io/gh/gramps-project/gramps/branch/maintenance/gramps60)
[![Translation status](https://hosted.weblate.org/widgets/gramps-project/-/gramps/svg-badge.svg)](https://hosted.weblate.org/engage/gramps-project)

We strive to produce a genealogy program that is both intuitive for hobbyists and feature-complete for professional genealogists.

Please read the [**COPYING**](https://github.com/gramps-project/gramps/blob/maintenance/gramps60/COPYING) file first.

Please read the [**INSTALL**](https://github.com/gramps-project/gramps/blob/maintenance/gramps60/INSTALL) file if you intend to build from source.

Requirements
============
The following packages **MUST** be installed in order for Gramps to work:

* [**Python**](https://www.python.org/) 3.9 or greater - The programming language used by Gramps.
* [**GTK**](http://www.gtk.org/) 3.24 or greater - A cross-platform widget toolkit for creating graphical user interfaces.
* [**pygobject**](https://wiki.gnome.org/Projects/PyGObject) 3.12 or greater - Python Bindings for GLib/GObject/GIO/GTK+

The following three packages with GObject Introspection bindings (the gi packages)

* [**cairo**](http://cairographics.org/) 1.14.0 or greater - a 2D graphics library with support for multiple output devices.
* [**Pycairo**](https://github.com/pygobject/pycairo) 1.13.3 or greater - GObject Introspection bindings for cairo.
* [**pango**](http://www.pango.org/) - a library for laying out and rendering of text, with an emphasis on internationalization.
* [**pangocairo**](http://www.pango.org/) - Allows you

orjson
PyGObject; extra == "gui"
pycairo; extra == "gui"
Pillow; extra == "all"
PyGObject; extra == "all"
PyICU; extra == "all"
imagesize; extra == "all"
pycairo; extra == "all"
pycountry; extra == "all"
PyICU; extra == "i18n"
Pillow; extra == "image"
jsonschema; extra == "testing"
lxml; extra == "testing"
mock; extra == "testing"

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

Natural Language :: Chinese (Simplified)

Operating System :: POSIX :: SunOS/Solaris


Summary: A cross-platform curses-based monitoring tool

Glances 🌟
==========

**Glances** is an open-source system cross-platform monitoring tool.
It allows real-time monitoring of various aspects of your system such as
CPU, memory, disk, network usage etc. It also allows monitoring of running processes,
logged in users, temperatures, voltages, fan speeds etc.
It also supports container monitoring, it supports different container management
systems such as Docker, LXC. The information is presented in an easy to read dashboard
and can also be used for remote monitoring of systems via a web interface or command
line interface. It is easy to install and use and can be customized to show only
the information that you are interested in.

In client/server mode, remote monitoring could be done via terminal,
Web interface or API (XML-RPC and RESTful).
Stats can also be exported to files or external time/value databases, CSV or direct
output to STDOUT.

Glances is written in Python and uses libraries to grab information from
your system. It is based on an open architecture where developers can
add new plugins or exports modules.

Usage 👋
========

For the standalone mode, just run:

.. code-block:: console

    $ glances

.. image:: https://github.com/nicolargo/glances/raw/refs/heads/master/docs/_static/glances-responsive-webdesign.png

For the Web server mode, run:

.. code-block:: console

    $ glances -w

and enter the URL ``http://<ip>:61208`` in your favorite web browser.

In this mode, a HTTP/Restful API is exposed, see document `RestfulApi`_ for more details.

.. image:: https://github.com/nicolargo/glances/raw/refs/heads/master/docs/_static/screenshot-web.png

For the client/server mode (remote monitoring through XML-RPC), run the following command on the server:

.. code-block:: console

    $ glances -s

and this one on the client:

.. code-block:: console

    $ glances -c <ip>

You can also detect and display all Glances servers available on your
network (or defined in the configuration file) in TUI:

.. code-block::

windows-curses; platform_system == "Windows"

batinfo; platform_system == "Linux" and extra == "sensors"

python-jose[cryptography]>=3.3.0; extra == "web"


Summary: Optional static typing for Python

Mypy -- Optional Static Typing for Python
=========================================

Add type annotations to your Python programs, and use mypy to type
check them.  Mypy is essentially a Python linter on steroids, and it
can catch many programming errors by analyzing your program, without
actually having to run it.  Mypy has a powerful type system with
features such as type inference, gradual typing, generics and union
types.

typing_extensions>=4.6.0; python_version < "3.15"

typing_extensions>=4.14.0; python_version >= "3.15"

librt>=0.13.0; platform_python_implementation != "PyPy"


Summary: Natural Language Toolkit

The Natural Language Toolkit (NLTK) is a Python package for
natural language processing.  NLTK requires Python 3.10, 3.11, 3.12, 3.13, or 3.14.

python-crfsuite; extra == "machine-learning"

scikit-learn; extra == "machine-learning"

License :: OSI Approved :: Apache Software License

Topic :: Scientific/Engineering :: Human Machine Interfaces

Topic :: Scientific/Engineering :: Information Analysis

NLP, CL, natural language processing, computational linguistics, parsing, tagging, tokenizing, syntax, linguistics, language, natural language, text analytics


Summary: Python framework for fast Vector Space Modelling

==============================================
gensim -- Topic Modelling in Python
==============================================

|GA|_
|Wheel|_

.. |GA| image:: https://github.com/RaRe-Technologies/gensim/actions/workflows/tests.yml/badge.svg?branch=develop
.. |Wheel| image:: https://img.shields.io/pypi/wheel/gensim.svg

.. _GA: https://github.com/RaRe-Technologies/gensim/actions
.. _Downloads: https://pypi.org/project/gensim/
.. _License: https://radimrehurek.com/gensim/intro.html#licensing
.. _Wheel: https://pypi.org/project/gensim/

Gensim is a Python library for *topic modelling*, *document indexing* and *similarity retrieval* with large corpora.
Target audience is the *natural language processing* (NLP) and *information retrieval* (IR) community.

Features
---------

* All algorithms are **memory-independent** w.r.t. the corpus size (can process input larger than RAM, streamed, out-of-core)
* **Intuitive interfaces**

  * easy to plug in your own input corpus/datastream (simple streaming API)
  * easy to extend with other Vector Space algorithms (simple transformation API)

* Efficient multicore implementations of popular algorithms, such as online **Latent Semantic Analysis (LSA/LSI/SVD)**,
  **Latent Dirichlet Allocation (LDA)**, **Random Projections (RP)**, **Hierarchical Dirichlet Process (HDP)** or **word2vec deep learning**.
* **Distributed computing**: can run *Latent Semantic Analysis* and *Latent Dirichlet Allocation* on a cluster of computers.
* Extensive `documentation and Jupyter Notebook tutorials <https://github.com/RaRe-Technologies/gensim/#documentation>`_.

If this feature list left you scratching your head, you can first read more about the `Vector
Space Model <https://en.wikipedia.org/wiki/Vector_space_model>`_ and `unsupervised
document analysis <https://en.wikipedia.org/wiki/Latent_semantic_indexing>`_ on Wikipedia.

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

This software depends on `NumPy and Scipy <https://scipy.org/install/>`_, two Python packages

sphinxcontrib.programoutput==0.17; extra == "docs"

sphinxcontrib-napoleon==0.7; extra == "docs"

Development Status :: 5 - Production/Stable

Singular Value Decomposition, SVD, Latent Semantic Indexing, LSA, LSI, Latent Dirichlet Allocation, LDA, Hierarchical Dirichlet Process, HDP, Random Projections, TFIDF, word2vec


Summary: Simple, Pythonic text processing. Sentiment analysis, part-of-speech tagging, noun phrase parsing, and more.

TextBlob: Simplified Text Processing
====================================

.. image:: https://badgen.net/pypi/v/TextBlob
    :target: https://pypi.org/project/textblob/
    :alt: Latest version

.. image:: https://github.com/sloria/TextBlob/actions/workflows/build-release.yml/badge.svg
    :target: https://github.com/sloria/TextBlob/actions/workflows/build-release.yml
    :alt: Build status

Homepage: `https://textblob.readthedocs.io/ <https://textblob.readthedocs.io/>`_

`TextBlob` is a Python library for processing textual data. It provides a simple API for diving into common natural language processing (NLP) tasks such as part-of-speech tagging, noun phrase extraction, sentiment analysis, classification, and more.

.. code-block:: python

    from textblob import TextBlob

    text = """
    The titular threat of The Blob has always struck me as the ultimate movie
    monster: an insatiably hungry, amoeba-like mass able to penetrate
    virtually any safeguard, capable of--as a doomed doctor chillingly
    describes it--"assimilating flesh on contact.
    Snide comparisons to gelatin be damned, it's a concept with the most
    devastating of potential consequences, not unlike the grey goo scenario
    proposed by technological theorists fearful of
    artificial intelligence run rampant.
    """

    blob = TextBlob(text)
    blob.tags  # [('The', 'DT'), ('titular', 'JJ'),
    #  ('threat', 'NN'), ('of', 'IN'), ...]

    blob.noun_phrases  # WordList(['titular threat', 'blob',
    #            'ultimate movie monster',
    #            'amoeba-like mass', ...])

    for sentence in blob.sentences:
        print(sentence.sentiment.polarity)
    # 0.060
    # -0.341

TextBlob stands on the giant shoulders of `NLTK`_ and `pattern`_, and plays nicely with both.

Features
--------

- Noun phrase extraction
- Part-of-speech tagging
- Sentiment analysis
- Classification (Naive Bayes, Decision Tree)
- Tokenization (splitting text into words and sentences)
- Word and

Intended Audience :: Developers
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 :: Text Processing :: Linguistic

textblob, nlp, linguistics, nltk, pattern


Summary: Python HTTP for Humans.

# Requests

[![Version](https://img.shields.io/pypi/v/requests.svg?maxAge=86400)](https://pypi.org/project/requests/)
[![Supported Versions](https://img.shields.io/pypi/pyversions/requests.svg)](https://pypi.org/project/requests)
[![Downloads](https://static.pepy.tech/badge/requests/month)](https://pepy.tech/project/requests)
[![Contributors](https://img.shields.io/github/contributors/psf/requests.svg)](https://github.com/psf/requests/graphs/contributors)
[![Documentation](https://readthedocs.org/projects/requests/badge/?version=latest)](https://requests.readthedocs.io)

**Requests** is a simple, yet elegant, HTTP library.

```python
>>> import requests
>>> r = requests.get('https://httpbin.org/basic-auth/user/pass', auth=('user', 'pass'))
>>> r.status_code
200
>>> r.headers['content-type']
'application/json; charset=utf8'
>>> r.encoding
'utf-8'
>>> r.text
'{"authenticated": true, ...'
>>> r.json()
{'authenticated': True, ...}
```

Requests allows you to send HTTP/1.1 requests extremely easily. There’s no need to manually add query strings to your URLs, or to form-encode your `PUT` & `POST` data — but nowadays, just use the `json` method!

Requests is one of the most downloaded Python packages today, pulling in around `300M downloads / week` — according to GitHub, Requests is currently [depended upon](https://github.com/psf/requests/network/dependents?package_id=UGFja2FnZS01NzA4OTExNg%3D%3D) by `4,000,000+` repositories.

## Installing Requests and Supported Versions

Requests is available on PyPI:

```console
$ python -m pip install requests
```

Requests officially supports Python 3.10+.

## Supported Features & Best–Practices

Requests is ready for the demands of building robust and reliable HTTP–speaking applications, for the needs of today.

- Keep-Alive & Connection Pooling
- International Domains and URLs
- Sessions with Cookie Persistence
- Browser-style TLS/SSL Verification
- Basic & Digest Authentication
- Familiar `dict`–like Cookies
- Automatic Content D

Ian Stapleton Cordasco <graffatcolmingov@gmail.com>, Nate Prewitt <nate.prewitt@gmail.com>

chardet<8,>=3.0.2; extra == "use-chardet-on-py3"

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

Programming Language :: Python :: Implementation :: CPython

Programming Language :: Python :: Implementation :: PyPy

Topic :: Software Development :: Libraries


Summary: HTTP library with thread-safe connection pooling, file post, and more.

![urllib3](https://github.com/urllib3/urllib3/raw/main/docs/_static/banner_github.svg)

urllib3 is a powerful, *user-friendly* HTTP client for Python.
urllib3 brings many critical features that are missing from the Python
standard libraries:

- Thread safety.
- Connection pooling.
- Client-side SSL/TLS verification.
- File uploads with multipart encoding.
- Helpers for retrying requests and dealing with HTTP redirects.
- Support for gzip, deflate, brotli, and zstd encoding.
- Proxy support for HT

Seth Michael Larson <sethmichaellarson@gmail.com>, Quentin Pradet <quentin@pradet.me>, Illia Volochii <illia.volochii@gmail.com>

brotli>=1.2.0; platform_python_implementation == "CPython" and extra == "brotli"

brotlicffi>=1.2.0.0; platform_python_implementation != "CPython" and extra == "brotli"

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

Programming Language :: Python :: 3 :: Only

filepost, http, httplib, https, pooling, ssl, threadsafe, urllib


Summary: Render rich text, tables, progress bars, syntax highlighting, markdown and more to the terminal

[![Supported Python Versions](https://img.shields.io/pypi/pyversions/rich)](https://pypi.org/project/rich/) [![PyPI version](https://badge.fury.io/py/rich.svg)](https://badge.fury.io/py/rich)

[![Downloads](https://pepy.tech/badge/rich/month)](https://pepy.tech/project/rich)
[![codecov](https://img.shields.io/codecov/c/github/Textualize/rich?label=codecov&logo=codecov)](https://codecov.io/gh/Textualize/rich)
[![Rich blog](https://img.shields.io/badge/blog-rich%20news-yellowgreen)](https://www.willmcgugan.com/tag/rich/)
[![Twitter Follow](https://img.shields.io/twitter/follow/willmcgugan.svg?style=social)](https://twitter.com/willmcgugan)

![Logo](https://github.com/textualize/rich/raw/master/imgs/logo.svg)

[English readme](https://github.com/textualize/rich/blob/master/README.md)
 • [简体中文 readme](https://github.com/textualize/rich/blob/master/README.cn.md)
 • [正體中文 readme](https://github.com/textualize/rich/blob/master/README.zh-tw.md)
 • [Lengua española readme](https://github.com/textualize/rich/blob/master/README.es.md)
 • [Deutsche readme](https://github.com/textualize/rich/blob/master/README.de.md)
 • [Läs på svenska](https://github.com/textualize/rich/blob/master/README.sv.md)
 • [日本語 readme](https://github.com/textualize/rich/blob/master/README.ja.md)
 • [한국어 readme](https://github.com/textualize/rich/blob/master/README.kr.md)
 • [Français readme](https://github.com/textualize/rich/blob/master/README.fr.md)
 • [Schwizerdütsch readme](https://github.com/textualize/rich/blob/master/README.de-ch.md)
 • [हिन्दी readme](https://github.com/textualize/rich/blob/master/README.hi.md)
 • [Português brasileiro readme](https://github.com/textualize/rich/blob/master/README.pt-br.md)
 • [Italian readme](https://github.com/textualize/rich/blob/master/README.it.md)
 • [Русский readme](https://github.com/textualize/rich/blob/master/README.ru.md)
 • [Indonesian readme](https://github.com/textualize/rich/blob/master/README.id.md)
 • [فارسی readme](https://github.com/textualize

ipywidgets<9,>=7.5.1; extra == "jupyter"

Operating System :: Microsoft :: Windows


    Typer, build great CLIs. Easy to code. Based on Python type hints.

---

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

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

---

Typer is a library for building CLI applications that users will **love using** and developers will **love creating**. Based on Python type hints.

It's also a command line tool to run scripts, automatically converting them to CLI applications.

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's easy to use for the final users. Automatic help, and automatic completion for all shells.
* **Short**: Minimize code duplication. Multiple features from each parameter declaration. Fewer bugs.
* **Start simple**: The simplest example adds only 2 lines of code to your app: **1 import, 1 function call**.
* **Grow large**: Grow in complexity as much as you

Intended Audience :: Information Technology

Intended Audience :: System Administrators

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

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


Summary: Data validation using Python type hints

# Pydantic Validation

[![CI](https://img.shields.io/github/actions/workflow/status/pydantic/pydantic/ci.yml?branch=main&logo=github&label=CI)](https://github.com/pydantic/pydantic/actions?query=event%3Apush+branch%3Amain+workflow%3ACI)
[![Coverage](https://coverage-badge.samuelcolvin.workers.dev/pydantic/pydantic.svg)](https://coverage-badge.samuelcolvin.workers.dev/redirect/pydantic/pydantic)
[![pypi](https://img.shields.io/pypi/v/pydantic.svg)](https://pypi.python.org/pypi/pydantic)
[![CondaForge](https://img.shields.io/conda/v/conda-forge/pydantic.svg)](https://anaconda.org/conda-forge/pydantic)
[![downloads](https://static.pepy.tech/badge/pydantic/month)](https://pepy.tech/project/pydantic)
[![versions](https://img.shields.io/pypi/pyversions/pydantic.svg)](https://github.com/pydantic/pydantic)
[![license](https://img.shields.io/github/license/pydantic/pydantic.svg)](https://github.com/pydantic/pydantic/blob/main/LICENSE)
[![Pydantic v2](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/pydantic/pydantic/main/docs/badge/v2.json)](https://docs.pydantic.dev/latest/contributing/#badges)
[![llms.txt](https://img.shields.io/badge/llms.txt-green)](https://docs.pydantic.dev/latest/llms.txt)

Data validation using Python type hints.

Fast and extensible, Pydantic plays nicely with your linters/IDE/brain.
Define how data should be in pure, canonical Python 3.9+; validate it with Pydantic.

## Pydantic Logfire :fire:

We've launched Pydantic Logfire to help you monitor your applications.
[Learn more](https://pydantic.dev/logfire/?utm_source=pydantic_validation)

## Pydantic V1.10 vs. V2

Pydantic V2 is a ground-up rewrite that offers many new features, performance improvements, and some breaking changes compared to Pydantic V1.

If you're using Pydantic V1 you may want to look at the
[pydantic V1.10 Documentation](https://docs.pydantic.dev/) or,
[`1.10.X-fixes` git branch](https://github.com/pydantic/pydantic/tree/1.10.X-fixes). Pydantic V2 also ships

Samuel Colvin <s@muelcolvin.com>, Eric Jolibois <em.jolibois@gmail.com>, Hasan Ramezani <hasan.r67@gmail.com>, Adrian Garcia Badaracco <1755071+adriangb@users.noreply.github.com>, Terrence Dorsey <terry@pydantic.dev>, David Montague <david@pydantic.dev>, Serge Matveenko <lig@countzero.co>, Marcelo Trylesinski <marcelotryle@gmail.com>, Sydney Runkle <sydneymarierunkle@gmail.com>, David Hewitt <mail@davidhewitt.dev>, Alex Hall <alex.mojaki@gmail.com>, Victorien Plot <contact@vctrn.dev>

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

tzdata; (python_version >= "3.9" and platform_system == "Windows") and extra == "timezone"


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 lightning-fast ASGI server.

An ASGI web server, for Python.

---

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

---

**Documentation**: [https://uvicorn.dev](https://uvicorn.dev)

**Source Code**: [https://www.github.com/Kludex/uvicorn](https://www.github.com/Kludex/uvicorn)

---

Uvicorn is an ASGI web server implementation for Python.

Until recently Python has lacked a minimal low-level server/application interface for
async frameworks. The [ASGI specification][asgi] fills this gap, and means we're now able to
start building a common set of tooling usable across all async frameworks.

Uvicorn supports HTTP/1.1 and WebSockets.

## Quickstart

Install using `pip`:

```shell
$ pip install uvicorn
```

This will install uvicorn with minimal (pure Python) dependencies.

```shell
$ pip install 'uvicorn[standard]'
```

This will install uvicorn with "Cython-based" dependencies (where possible) and other "optional extras".

In this context, "Cython-based" means the following:

- the event loop `uvloop` will be installed and used if possible.
- the http protocol will be handled by `httptools` if possible.

Moreover, "optional extras" means that:

- the websocket protocol will be handled by `websockets` (should you want to use `wsproto` you'd need to install it manually) if possible.
- the `--reload` flag in development mode will use `watchfiles`.
- `pytho

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

python-dotenv>=0.13; extra == "standard"

uvloop>=0.15.1; (sys_platform != "win32" and (sys_platform != "cygwin" and platform_python_implementation != "PyPy")) and extra == "standard"


Summary: pytest: simple powerful testing with Python

.. image:: https://github.com/pytest-dev/pytest/raw/main/doc/en/img/pytest_logo_curves.svg
   :target: https://docs.pytest.org/en/stable/
   :align: center
   :height: 200
   :alt: pytest

------

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

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

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

.. image:: https://codecov.io/gh/pytest-dev/pytest/branch/main/graph/badge.svg
    :target: https://codecov.io/gh/pytest-dev/pytest
    :alt: Code coverage Status

.. image:: https://github.com/pytest-dev/pytest/actions/workflows/test.yml/badge.svg
    :target: https://github.com/pytest-dev/pytest/actions?query=workflow%3Atest

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

.. image:: https://www.codetriage.com/pytest-dev/pytest/badges/users.svg
    :target: https://www.codetriage.com/pytest-dev/pytest

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

.. image:: https://img.shields.io/badge/Discord-pytest--dev-blue
    :target: https://discord.com/invite/pytest-dev
    :alt: Discord

.. image:: https://img.shields.io/badge/Libera%20chat-%23pytest-orange
    :target: https://web.libera.chat/#pytest
    :alt: Libera chat

The ``pytest`` framework makes it easy to write small tests, yet
scales to support complex functional testing for applications and libraries.

An example of a simple test:

.. code-block:: python

    # content of test_sample.py
    def inc(x):
        return x + 1

    def test_answer():
        assert inc(3) == 5

To execute it::

    $ pytest
    =====================

Brianna Laugher, Bruno Oliveira, Floris Bruynooghe, Freya Bruhin, Holger Krekel, Others (See AUTHORS), Ronny Pfannschmidt

exceptiongroup>=1; python_version < "3.11"

Topic :: Software Development :: Testing


Summary: Python package for providing Mozilla's CA Bundle.

Certifi: Python SSL Certificates
================================

Certifi provides Mozilla's carefully curated collection of Root Certificates for
validating the trustworthiness of SSL certificates while verifying the identity
of TLS hosts. It has been extracted from the `Requests`_ project.

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

``certifi`` is available on PyPI. Simply install it with ``pip``::

    $ pip install certifi

Usage
-----

To reference the installed certificate authority (CA) bundle, you can use the
built-in function::

    >>> import certifi

    >>> certifi.where()
    '/usr/local/lib/python3.7/site-packages/certifi/cacert.pem'

Or from the command line::

    $ python -m certifi
    /usr/local/lib/python3.7/site-packages/certifi/cacert.pem

Enjoy!

.. _`Requests`: https://requests.readthedocs.io/en/latest/

Addition/Removal of Certificates
--------------------------------

Certifi does not support any addition/removal or other modification of the
CA trust store content. This project is intended to provide a reliable and
highly portable root of trust to python deployments. Look to upstream projects
for methods to use alternate trust.

License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)


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


# uv

An extremely fast Python package and project manager, written in Rust.

  Installing Trio's dependencies with a warm cache.

## Highlights

- A single tool to replace `pip`, `pip-tools`, `pipx`, `poetry`, `pyenv`, `twine`, `virtualenv`, and
  more.
- [10-100x faster](https://github.com/astral-sh/uv/blob/main/BENCHMARKS.md) than `pip`.
- Provides [comprehensive project management](https://github.com/astral-sh/uv/blob/0.12.1/README.md#projects), with a
  [universal lockfile](https://docs.astral.sh/uv/concepts/projects/layout#the-lockfile).
- [Runs scripts](https://github.com/astral-sh/uv/blob/0.12.1/README.md#scripts), with support for
  [inline dependency metadata](https://docs.astral.sh/uv/guides/scripts#declaring-script-dependencies).
- [Installs and manages](https://github.com/astral-sh/uv/blob/0.12.1/README.md#python-versions) Python versions.
- [Runs and installs](https://github.com/astral-sh/uv/blob/0.12.1/README.md#tools) tools published as Python packages.
- Includes a [pip-compatible interface](https://github.com/astral-sh/uv/blob/0.12.1/README.md#the-pip-interface) for a performance boost with a familiar
  CLI.
- Supports Cargo-style [workspaces](https://docs.astral.sh/uv/concepts/projects/workspaces) for
  scalable projects.
- Disk-space efficient, with a [global cache](https://docs.astral.sh/uv/concepts/cache) for
  dependency deduplication.
- Installable without Rust or Python via `curl` or `pip`.
- Supports macOS, Linux, and Windows.

uv is backed by [Astral](https://astral.sh), the creators of
[Ruff](https://github.com/astral-sh/ruff) and [ty](https://github.com/astral-sh/ty).

## Installation

Install uv with our standalone installers:

```bash
# On macOS and Linux.
curl -LsSf https://astral.sh/uv/install

Topic :: Software Development :: Quality Assurance


Summary: The Cython compiler for writing C extensions in the Python language.

The Cython language makes writing C extensions for the Python language as
easy as Python itself.  Cython is a source code translator based on Pyrex_,
but supports more cutting edge functionality and optimizations.

The Cython language is a superset of the Python language (almost all Python
code is also valid Cython code), but Cython additionally supports optional
static typing to natively call C functions, operate with C++ classes and
declare fast C types on variables and class attributes.  This allows the
compiler to generate very efficient C code from Cython code.

This makes Cython the ideal language for writing glue code for external
C/C++ libraries, and for fast C modules that speed up the execution of
Python code.

The newest Cython release can always be downloaded from https://cython.org/.
Unpack the tarball or zip file, enter the directory, and then run::

    pip install .

Note that for one-time builds, e.g. for CI/testing, on platforms that are not
covered by one of the wheel packages provided on PyPI *and* the pure Python wheel
that we provide is not used, it is substantially faster than a full source build
to install an uncompiled (slower) version of Cython with::

    NO_CYTHON_COMPILE=true pip install .

.. _Pyrex: https://www.cosc.canterbury.ac.nz/greg.ewing/python/Pyrex/

3.2.9 (2026-07-23)
==================

Bugs fixed
----------

* Indexing into freshly created lists with an out-of-bounds index could crash.
  (Github issue https://github.com/cython/cython/issues/7793)

* Function arguments with default values could end up uninitialised in closures, leading to crashes.
  Patch by Anthony Donlon.  (Github issue https://github.com/cython/cython/issues/7782)

* ``bytearray.append(None)`` could crash. The optimised code was also lacking concurrency guards.
  (Github issue https://github.com/cython/cython/issues/7796)

* Some rare corner cases when concatenating text strings were resolved.
  (Github issue https://github.com/cython/cython/issues/7799)

Robert Bradshaw, Stefan Behnel, David Woods, Greg Ewing, et al.

Programming Language :: Python :: Implementation :: Stackless

Topic :: Software Development :: Code Generators

Topic :: Software Development :: Compilers


Summary: Python compiler with full language support and CPython compatibility

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

.. image:: https://badge.fury.io/py/Nuitka.svg
   :target: https://pypi.org/project/Nuitka

.. image:: https://img.shields.io/badge/Contributor%20Covenant-v1.4%20adopted-ff69b4.svg
   :target: CODE_OF_CONDUCT.md

####################
 Nuitka User Manual
####################

This document is the recommended first read when you start using
**Nuitka**. On this page, you will learn more about **Nuitka**
fundamentals, such as license type, use cases, requirements, and
credits.

.. contents:: Table of Contents
   :depth: 1
   :local:
   :class: page-toc

Nuitka is **the** Python compiler. It is written in Python. It is a
seamless replacement or extension to the Python interpreter and compiles
**every** construct that Python 2 (2.6, 2.7) and Python 3 (3.4 - 3.14)
have, when itself run with that Python version.

It then executes uncompiled code and compiled code together in an
extremely compatible manner.

You can use all Python library modules and all extension modules freely.

Nuitka translates the Python modules into a C level program that then
uses ``libpython`` and static C files of its own to execute in the same
way as CPython does.

All optimization is aimed at avoiding overhead, where it's unnecessary.
None is aimed at removing compatibility, although slight improvements
will occasionally be done, where not every bug of standard Python is
emulated, e.g. more complete error messages are given, but there is a
full compatibility mode to disable even that.

**************
 Requirements
**************

To ensure smooth operation of **Nuitka**, make sure to follow system
requirements, that include the following components:

   :depth: 1
   :local:

C Compiler
==========

You need a C compiler with support for C11 or alternatively a C++
compiler for C++03 [#]_.

Currently, this means, you need to use one of these compilers:

-  The ``zig`` compiler (used with ``--zig`

setuptools>=42; extra == "build-wheel"
toml; extra == "build-wheel"
wheel; extra == "build-wheel"
zstandard>=0.15; extra == "onefile"
zstandard>=0.15; extra == "app"
imageio; extra == "icon-conversion"
setuptools>=42; extra == "all"
toml; extra == "all"
zstandard>=0.15; extra == "all"
imageio; extra == "all"

Development Status :: 5 - Production/Stable

License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)

Operating System :: POSIX :: BSD :: FreeBSD

Operating System :: POSIX :: BSD :: NetBSD

Operating System :: POSIX :: BSD :: OpenBSD

Programming Language :: Python :: Implementation :: CPython

Topic :: Software Development :: Build Tools

Topic :: System :: Software Distribution


PyInstaller Overview
====================

.. image:: https://img.shields.io/pypi/v/pyinstaller
   :alt: PyPI
   :target: https://pypi.org/project/pyinstaller
.. image:: https://img.shields.io/pypi/pyversions/pyinstaller
   :alt: PyPI - Python Version
   :target: https://pypi.org/project/pyinstaller
.. image:: https://img.shields.io/readthedocs/pyinstaller/stable
   :alt: Read the Docs (version)
   :target: https://pyinstaller.org
.. image:: https://img.shields.io/pypi/dm/pyinstaller
   :alt: PyPI - Downloads
   :target: https://pypistats.org/packages/pyinstaller

PyInstaller bundles a Python application and all its dependencies into a single
package. The user can run the packaged app without installing a Python
interpreter or any modules.

:Documentation: https://pyinstaller.org/
:Code:          https://github.com/pyinstaller/pyinstaller

PyInstaller reads a Python script written by you. It analyzes your code
to discover every other module and library your script needs in order to
execute. Then it collects copies of all those files -- including the active
Python interpreter! -- and puts them with your script in a single folder, or
optionally in a single executable file.

PyInstaller is tested against Windows, macOS, and GNU/Linux.
However, it is not a cross-compiler:
to make a Windows app you run PyInstaller in Windows; to make
a GNU/Linux app you run it in GNU/Linux, etc.
PyInstaller has been used successfully
with AIX, Solaris, FreeBSD and OpenBSD,
but is not tested against them as part of the continuous integration tests.

Main Advantages
---------------

- Works out-of-the-box with any Python version 3.8-3.15.
- Fully multi-platform, and uses the OS support to load the dynamic libraries,
  thus ensuring full compatibility.
- Correctly bundles the major Python packages such as numpy, PyQt5,
  PySide2, PyQt6, PySide6, wxPython, matplotlib and others out-of-the-box.
- Compatible with many third-party packages out-of-the-box. (All the required
  tricks to make e

Hartmut Goebel, Giovanni Bajo, David Vierra, David Cortesi, Martin Zibricky

GPLv2-or-later with a special exception which allows to use PyInstaller to build and distribute non-free programs (including commercial ones)

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

pefile>=2022.5.30; sys_platform == "win32"

pywin32-ctypes>=0.2.1; sys_platform == "win32"

Intended Audience :: System Administrators

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

Operating System :: Microsoft :: Windows

Operating System :: POSIX :: SunOS/Solaris

Programming Language :: Python :: 3 :: Only

Topic :: Software Development :: Interpreters

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

app, apps, bundle, convert, executable, packaging, standalone


Summary: Create standalone executables from Python scripts

**cx_Freeze** Creates standalone executables from Python scripts with the same performance
as the original script.

It is cross-platform and should work on any platform that Python runs on.

[![PyPI version](https://img.shields.io/pypi/v/cx_Freeze)](https://pypi.org/project/cx-freeze/)
[![PyPi Downloads](https://img.shields.io/pypi/dm/cx_Freeze)](https://pypistats.org/packages/cx-freeze)
[![Conda Version](https://img.shields.io/conda/vn/conda-forge/cx_freeze.svg)](https://anaconda.org/conda-forge/cx_freeze)
[![Conda Downloads](https://anaconda.org/conda-forge/cx_freeze/badges/downloads.svg)](https://anaconda.org/conda-forge/cx_freeze)
[![Python](https://img.shields.io/pypi/pyversions/cx-freeze)](https://www.python.org/)
[![Actions status](https://github.com/marcelotduarte/cx_Freeze/workflows/CI/badge.svg)](https://github.com/marcelotduarte/cx_Freeze/actions/workflows/ci.yml)
[![CodeQL](https://github.com/marcelotduarte/cx_Freeze/workflows/CodeQL/badge.svg)](https://github.com/marcelotduarte/cx_Freeze/actions/workflows/codeql.yml)
[![Coverage](https://raw.githubusercontent.com/marcelotduarte/cx_Freeze/python-coverage-comment-action-data/badge.svg)](https://htmlpreview.github.io/?https://github.com/marcelotduarte/cx_Freeze/blob/python-coverage-comment-action-data/htmlcov/index.html)
[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
[![Documentation Status](https://readthedocs.org/projects/cx-freeze/badge/?version=stable)](https://cx-freeze.readthedocs.io/en/stable/?badge=stable)

# Installation

Choose the Python package manager according to your system. See how the
installation works with the most common ones, which are pip and conda.

To install the latest version of `cx_Freeze` using `pip` into a
virtual environment:

```
pip install --upgrade cx_Freeze
```

To install the latest development build:

```
pip uninstall cx_Freeze
pip install --extra-index-url htt

Marcelo Duarte <marcelotduarte@users.noreply.github.com>, Anthony Tuininga <anthony.tuininga@gmail.com>

filelock>=3.20.3; sys_platform == "linux"

patchelf<0.18,>=0.16.1; sys_platform == "linux" and platform_machine == "x86_64"

patchelf<0.18,>=0.16.1; sys_platform == "linux" and platform_machine == "i686"

patchelf<0.18,>=0.16.1; sys_platform == "linux" and platform_machine == "aarch64"

patchelf<0.18,>=0.16.1; sys_platform == "linux" and platform_machine == "armv7l"

patchelf<0.18,>=0.16.1; sys_platform == "linux" and platform_machine == "ppc64le"

patchelf<0.18,>=0.16.1; sys_platform == "linux" and platform_machine == "s390x"

dmgbuild>=1.6.1; sys_platform == "darwin"

python-msilib>=0.4.1; sys_platform == "win32" and python_version >= "3.13"

cx-freeze cxfreeze cx_Freeze freeze python


Summary: Command line tool for manipulating wheel files

wheel
=====

This is a command line tool for manipulating Python wheel files, as defined in
`PEP 427`_. It contains the following functionality:

* Convert ``.egg`` archives into ``.whl``
* Unpack wheel archives
* Repack wheel archives
* Add or remove tags in existing wheel archives

.. _PEP 427: https://peps.python.org/pep-0427/

Historical note
---------------

This project used to contain the implementation of the setuptools_ ``bdist_wheel``
command, but as of setuptools v70.1, it no longer needs ``wheel`` installed for that to
work. Thus, you should install this **only** if you intend to use the ``wheel`` command
line tool!

.. _setuptools: https://pypi.org/project/setuptools/

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

The documentation_ can be found on Read The Docs.

.. _documentation: https://wheel.readthedocs.io/

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

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

.. _PSF Code of Conduct: https://github.com/pypa/.github/blob/main/CODE_OF_CONDUCT.md

Topic :: System :: Archiving :: Packaging


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 :: Implementation :: PyPy


Summary: Modern, extensible Python project management

# Hatch

| | |
| --- | --- |
| CI/CD | [![CI - Test](https://github.com/pypa/hatch/actions/workflows/test.yml/badge.svg)](https://github.com/pypa/hatch/actions/workflows/test.yml) [![CD - Build Hatch](https://github.com/pypa/hatch/actions/workflows/build-hatch.yml/badge.svg)](https://github.com/pypa/hatch/actions/workflows/build-hatch.yml) [![CD - Build Hatchling](https://github.com/pypa/hatch/actions/workflows/build-hatchling.yml/badge.svg)](https://github.com/pypa/hatch/actions/workflows/build-hatchling.yml) |
| Docs | [![Docs - Release](https://github.com/pypa/hatch/actions/workflows/docs-release.yml/badge.svg)](https://github.com/pypa/hatch/actions/workflows/docs-release.yml) [![Docs - Dev](https://github.com/pypa/hatch/actions/workflows/docs-dev.yml/badge.svg)](https://github.com/pypa/hatch/actions/workflows/docs-dev.yml) |
| Package | [![PyPI - Version](https://img.shields.io/pypi/v/hatch.svg?logo=pypi&label=PyPI&logoColor=gold)](https://pypi.org/project/hatch/) [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/hatch.svg?logo=python&label=Python&logoColor=gold)](https://pypi.org/project/hatch/) [![PyPI - Installs](https://img.shields.io/pypi/dm/hatchling.svg?color=blue&label=Installs&logo=pypi&logoColor=gold)](https://pypi.org/project/hatch/) [![Release - Downloads](https://img.shields.io/github/downloads/pypa/hatch/total?label=Downloads)](https://github.com/pypa/hatch/releases) |
| Meta | [![Hatch project](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/pypa/hatch/master/docs/assets/badge/v0.json)](https://github.com/pypa/hatch) [![linting - Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff) [![types - Mypy](https://img.shields.io/badge/types-Mypy-blue.svg)](https://git

Ofek Lev <oss@ofek.dev>, Cary Hawkins <hawkinscary23@gmail.com>

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

Development Status :: 5 - Production/Stable

build, dependency, environment, hatch, packaging, plugin, publishing, release, versioning


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: 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 :: Scientific/Engineering :: Artificial Intelligence

Topic :: Scientific/Engineering :: Mathematics

Topic :: Software Development :: Libraries


Summary: Apache Beam SDK for Python

# Apache Beam

[Apache Beam](http://beam.apache.org/) is a unified model for defining both batch and streaming data-parallel processing pipelines, as well as a set of language-specific SDKs for constructing pipelines and Runners for executing them on distributed processing backends, including [Apache Flink](http://flink.apache.org/), [Apache Spark](http://spark.apache.org/), [Google Cloud Dataflow](http://cloud.google.com/dataflow/), and [Hazelcast Jet](https://jet.hazelcast.org/).

## Overview

Beam provides a general approach to expressing [embarrassingly parallel](https://en.wikipedia.org/wiki/Embarrassingly_parallel) data processing pipelines and supports three categories of users, each of which have relatively disparate backgrounds and needs.

1. _End Users_: Writing pipelines with an existing SDK, running it on an existing runner. These users want to focus on writing their application logic and have everything else just work.
2. _SDK Writers_: Developing a Beam SDK targeted at a specific user community (Java, Python, Scala, Go, R, graphical, etc). These users are language geeks and would prefer to be shielded from all the details of various runners and their implementations.
3. _Runner Writers_: Have an execution environment for distributed processing and would like to support programs written against the Beam Model. Would prefer to be shielded from details of multiple SDKs.

### The Beam Model

The model behind Beam evolved from several internal Google data processing projects, including [MapReduce](http://research.google.com/archive/mapreduce.html), [FlumeJava](http://research.google.com/pubs/pub35650.html), and [Millwheel](http://research.google.com/pubs/pub41378.html). This model was originally known as the “[Dataflow Model](http://www.vldb.org/pvldb/vol8/p1792-Akidau.pdf)”.

To learn more about the Beam Model (though still under the original name of Dataflow), see the World Beyond Batch: [Streaming 101](https://www.oreilly.com/ideas/the-world-beyond-bat

envoy-data-plane<2,>=1.0.3; python_version >= "3.11"

envoy-data-plane<0.3.0; python_version < "3.11"

docstring-parser<1.0,>=0.15; extra == "docs"

virtualenv-clone<1.0,>=0.5; extra == "docs"

cloud-sql-python-connector[pg8000]<2.0.0,>=1.0.0; extra == "test"

docstring-parser<1.0,>=0.15; extra == "test"

parameterized<0.10.0,>=0.7.1; extra == "test"

requests_mock<2.0,>=1.7; extra == "test"

pytest-timeout<3,>=2.1.0; extra == "test"

psycopg2-binary<3.0,>=2.8.5; extra == "test"

testcontainers[kafka,milvus,mysql,qdrant]<5.0.0,>=4.0.0; extra == "test"

virtualenv-clone<1.0,>=0.5; extra == "test"

sqlalchemy-pytds>=1.0.2; extra == "test"

google-api-core<3,>=2.0.0; extra == "gcp"

google-apitools<0.5.32,>=0.5.31; python_version < "3.13" and extra == "gcp"

google-apitools>=0.5.35; python_version >= "3.13" and extra == "gcp"

google-auth-httplib2<0.3.0,>=0.1.0; extra == "gcp"

google-cloud-datastore<3,>=2.0.0; extra == "gcp"

google-cloud-pubsub<3,>=2.1.0; extra == "gcp"

google-cloud-storage<4,>=2.18.2; extra == "gcp"

google-cloud-resource-manager<2,>=1.12.0; extra == "gcp"

google-cloud-dataflow-client<0.14.0,>=0.13.0; extra == "gcp"

google-cloud-bigquery<4,>=2.0.0; extra == "gcp"

google-cloud-bigquery-storage<3,>=2.6.3; extra == "gcp"

google-cloud-core<3,>=2.0.0; extra == "gcp"

google-cloud-bigtable<3,>=2.19.0; extra == "gcp"

google-cloud-build<4,>=3.35.0; extra == "gcp"

google-cloud-spanner<4,>=3.0.0; extra == "gcp"

google-cloud-dlp<4,>=3.0.0; extra == "gcp"

google-cloud-kms<4,>=3.0.0; extra == "gcp"

google-cloud-language<3,>=2.0; extra == "gcp"

google-cloud-secret-manager<3,>=2.0; extra == "gcp"

google-cloud-videointelligence<3,>=2.0; extra == "gcp"

google-cloud-vision<4,>=2; extra == "gcp"

google-cloud-recommendations-ai<0.11.0,>=0.1.0; extra == "gcp"

google-cloud-aiplatform<2.0,>=1.26.0; extra == "gcp"

cloud-sql-python-connector<2.0.0,>=1.18.2; extra == "gcp"

keyrings.google-artifactregistry-auth; extra == "gcp"

facets-overview<2,>=1.1.0; extra == "interactive"

google-cloud-dataproc<6,>=5.0.0; extra == "interactive"

ipywidgets<9,>=8; extra == "interactive"

timeloop<2,>=1.0.2; extra == "interactive"

nbformat<6,>=5.0.5; extra == "interactive"

nbconvert<8,>=6.2.0; extra == "interactive"

needle<1,>=0.5.0; extra == "interactive-test"

chromedriver-binary<118,>=117; extra == "interactive-test"

pillow<10,>=7.1.1; extra == "interactive-test"

urllib3<2,>=1.21.1; extra == "interactive-test"

tensorflow_transform<1.15.0,>=1.14.0; extra == "ml-test"

sentence-transformers>=2.2.2; extra == "ml-test"

transformers<4.56.0,>=4.28.0; extra == "ml-test"

embeddings>=0.0.4; extra == "p310-ml-test"

sentence-transformers>=2.2.2; extra == "p310-ml-test"

tokenizers<0.23; extra == "p310-ml-test"

google-adk==1.28.1; extra == "p310-ml-test"

opentelemetry-api==1.37.0; extra == "p310-ml-test"

opentelemetry-sdk==1.37.0; extra == "p310-ml-test"

opentelemetry-exporter-otlp-proto-http==1.37.0; extra == "p310-ml-test"

qdrant-client>=1.15.0; extra == "p310-ml-test"

embeddings>=0.0.4; extra == "p312-ml-test"

sentence-transformers>=2.2.2; extra == "p312-ml-test"

tokenizers<0.23; extra == "p312-ml-test"

google-adk==1.28.1; extra == "p312-ml-test"

opentelemetry-api==1.37.0; extra == "p312-ml-test"

opentelemetry-sdk==1.37.0; extra == "p312-ml-test"

opentelemetry-exporter-otlp-proto-http==1.37.0; extra == "p312-ml-test"

qdrant-client>=1.15.0; extra == "p312-ml-test"

embeddings>=0.0.4; extra == "p313-ml-test"

sentence-transformers>=2.2.2; extra == "p313-ml-test"

tokenizers<0.23; extra == "p313-ml-test"

google-adk==1.28.1; extra == "p313-ml-test"

opentelemetry-api==1.37.0; extra == "p313-ml-test"

opentelemetry-sdk==1.37.0; extra == "p313-ml-test"

opentelemetry-exporter-otlp-proto-http==1.37.0; extra == "p313-ml-test"

qdrant-client>=1.15.0; extra == "p313-ml-test"

azure-storage-blob<13,>=12.3.2; extra == "azure"

azure-identity<2,>=1.12.0; extra == "azure"

docstring-parser<1.0,>=0.15; extra == "yaml"

virtualenv-clone<1.0,>=0.5; extra == "yaml"

jsonschema<5.0.0,>=4.0.0; extra == "yaml"

tensorflow<2.21,>=2.12rc1; extra == "tensorflow"

transformers<4.56.0,>=4.28.0; extra == "transformers"

tensorflow>=2.12.0; extra == "transformers"

torch<2.12.0,>=1.9.0; extra == "transformers"

transformers<4.56.0,>=4.28.0; extra == "ml-cpu"

tensorflow_transform<1.15.0,>=1.14.0; extra == "tft"

xgboost<2.1.3,>=1.6.0; extra == "xgboost"

tensorflow-hub<0.16.0,>=0.14.0; extra == "tensorflow-hub"

qdrant-client>=1.15.0; extra == "qdrant"