Summary: An open-source SDK for working with quantum computers at the level of extended quantum circuits, operators, and primitives.

# Qiskit

[![License](https://img.shields.io/github/license/Qiskit/qiskit.svg?)](https://opensource.org/licenses/Apache-2.0) <!--- long-description-skip-begin -->
[![Current Release](https://img.shields.io/github/release/Qiskit/qiskit.svg?logo=Qiskit)](https://github.com/Qiskit/qiskit/releases)
[![Extended Support Release](https://img.shields.io/github/v/release/Qiskit/qiskit?sort=semver&filter=1.*&logo=Qiskit&label=extended%20support)](https://github.com/Qiskit/qiskit/releases?q=tag%3A1)
[![Downloads](https://img.shields.io/pypi/dm/qiskit.svg)](https://pypi.org/project/qiskit/)
[![Coverage Status](https://coveralls.io/repos/github/Qiskit/qiskit/badge.svg?branch=main)](https://coveralls.io/github/Qiskit/qiskit?branch=main)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/qiskit)
[![Minimum rustc 1.87](https://img.shields.io/badge/rustc-1.87+-blue.svg)](https://rust-lang.github.io/rfcs/2495-min-rust-version.html)
[![Downloads](https://static.pepy.tech/badge/qiskit)](https://pepy.tech/project/qiskit)<!--- long-description-skip-end -->
[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.2583252.svg)](https://doi.org/10.5281/zenodo.2583252)

**Qiskit** is an open-source SDK for working with quantum computers at the level of extended quantum circuits, operators, and primitives.

This library is the core component of Qiskit, which contains the building blocks for creating and working with quantum circuits, quantum operators, and primitive functions (Sampler and Estimator).
It also contains a transpiler that supports optimizing quantum circuits, and a quantum information toolbox for creating advanced operators.

Qiskit provides two public APIs: a Python API and a C API. The Python API is the primary interface and prior to Qiskit 2.0 was the only public API available
for Qiskit. The C API is designed to provide direct access to Qiskit's internal data model (which is written in Rust). The C API can be consumed as either a
shared library (`libqiskit.so`) for st

Qiskit Development Team <qiskit@us.ibm.com>

qiskit-qasm3-import>=0.1.0; extra == "qasm3-import"

matplotlib>=3.3; extra == "visualization"

pylatexenc>=1.4; extra == "visualization"

seaborn>=0.9.0; extra == "visualization"

z3-solver>=4.7; extra == "crosstalk-pass"

python-constraint>=1.4; extra == "csp-layout-pass"

symengine<0.14,>=0.11; extra == "qpy-compat"

qiskit[crosstalk-pass,csp-layout-pass,qasm3-import,qpy-compat,visualization]; extra == "all"

Operating System :: Microsoft :: Windows

Programming Language :: Python :: 3 :: Only

qiskit, quantum circuit, quantum computing, quantum programming language, quantum, sdk


Summary: An Interactive Grid for Sorting and Filtering DataFrames in Jupyter Notebook

Topic :: Scientific/Engineering :: Information Analysis


  <picture>
      <source media="(prefers-color-scheme: dark)" srcset="https://github.com/qdrant/qdrant/raw/master/docs/logo-dark.svg">
      <source media="(prefers-color-scheme: light)" srcset="https://github.com/qdrant/qdrant/raw/master/docs/logo-light.svg">

  </picture>

    Python Client library for the Qdrant vector search engine.

# Python Qdrant Client

Client library and SDK for the [Qdrant](https://github.com/qdrant/qdrant) vector search engine.

Library contains type definitions for all Qdrant API and allows to make both Sync and Async requests.

Client allows calls for all [Qdrant API methods](https://api.qdrant.tech/) directly.
It also provides some additional helper methods for frequently required operations, e.g. initial collection uploading.

See [QuickStart](https://qdrant.tech/documentation/quick-start/#create-collection) for more details!

## Installation

```
pip install qdrant-client
```

## Features

- Type hints for all API methods
- Local mode - use same API without running server
- REST and gRPC support
- Minimal dep

fastembed<0.9,>=0.8; extra == "fastembed"

fastembed-gpu<0.9,>=0.8; extra == "fastembed-gpu"

License :: OSI Approved :: Apache Software License

vector, search, neural, matching, client


Summary: FontAwesome icons in PyQt and PySide applications

# QtAwesome

[![license](https://img.shields.io/pypi/l/qtawesome.svg)](./LICENSE)
[![pypi version](https://img.shields.io/pypi/v/qtawesome.svg)](https://pypi.org/project/qtawesome/)
[![conda version](https://img.shields.io/conda/vn/conda-forge/qtawesome.svg)](https://www.anaconda.com/download/)
[![download count](https://img.shields.io/conda/d/conda-forge/qtawesome.svg)](https://www.anaconda.com/download/)
[![OpenCollective Backers](https://opencollective.com/spyder/backers/badge.svg?color=blue)](#backers)
[![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/qtawesome.svg)](https://github.com/spyder-ide/qtawesome)
[![Github Windows build status](https://github.com/spyder-ide/qtawesome/workflows/Windows%20tests/badge.svg)](https://github.com/spyder-ide/qtawesome/actions)
[![Github Linux build status](https://github.com/spyder-ide/qtawesome/workflows/Linux%20tests/badge.svg)](https://github.com/spyder-ide/qtawesome/actions)
[![Github MacOS build status](https://github.com/spyder-ide/qtawesome/workflows/Macos%20tests/badge.svg)](https://github.com/spyder-ide/qtawesome/actions)
[![Documentation Status](https://readthedocs.org/projects/qtawesome/badge/?version=latest)](https://qtawesome.readthedocs.io/en/latest/?badge=latest)
[![codecov](https://codecov.io/gh/spyder-ide/qtawesome/branch/master/graph/badge.svg?token=Cylan0teq1)](https://codecov.io/gh/spyder-ide/qtawesome)

*Copyright © 2015- Spyder Project Contributors*

## Description

QtAwesome enables iconic fonts such as Font Awesome and Elusive Icons
in PyQt and PySide applications.

It started as a Python port of the [QtAwesome](
https://github.com/Gamecreature/qtawesome)
C++ library by Rick Blommers.

## Installation

Using `conda`:

```
conda install qtawesome
```

or using `pip` (only if you don't have conda installed):

```
pip install qtawesome
```

## Usage

### Su

Sylvain Corlay and the Spyder Development Team

Spyder Development Team and QtAwesome Contributors

Development Status :: 5 - Production/Stable

Topic :: Software Development :: User Interfaces

PyQt, PySide, Icons, Font Awesome, Fonts


Summary: Python bindings for the QuantLib library

QuantLib (https://www.quantlib.org/) is a free/open-source C++ library
for financial quantitative analysts and developers, aimed at providing
a comprehensive software framework for quantitative finance.

QuantLib is Non-Copylefted Free Software and OSI Certified Open Source Software.

Free-threading wheels are also provided.  Note, though, that the
underlying C++ library is not thread-safe.  It has globals (most
notably, the evaluation date) that in the current version of the
wheels can't be set per thread.  Also, we suggest to avoid sharing
objects and state across threads; each thread should have its set of
curves and instruments.  Given that they calculate and cache results
lazily, sharing them will probably lead to data races.

Intended Audience :: Financial and Insurance Industry

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


Summary: Aer - High performance simulators for Qiskit

# Aer - high performance quantum circuit simulation for Qiskit

[![License](https://img.shields.io/github/license/Qiskit/qiskit-aer.svg?style=popout-square)](https://opensource.org/licenses/Apache-2.0)
[![Build](https://github.com/Qiskit/qiskit-aer/actions/workflows/build.yml/badge.svg?branch=main)](https://github.com/Qiskit/qiskit-aer/actions/workflows/build.yml)
[![Tests](https://github.com/Qiskit/qiskit-aer/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/Qiskit/qiskit-aer/actions/workflows/tests.yml)
[![](https://img.shields.io/github/release/Qiskit/qiskit-aer.svg?style=popout-square)](https://github.com/Qiskit/qiskit-aer/releases)
[![](https://img.shields.io/pypi/dm/qiskit-aer.svg?style=popout-square)](https://pypi.org/project/qiskit-aer/)

**Aer** is a high performance simulator for quantum circuits written in Qiskit, that includes realistic noise models.

## Installation

We encourage installing Aer via the pip tool (a python package manager):

```bash
pip install qiskit-aer
```

Pip will handle all dependencies automatically for us, and you will always install the latest (and well-tested) version.

To install from source, follow the instructions in the [contribution guidelines](CONTRIBUTING.md).

## Installing GPU support

In order to install and run the GPU supported simulators on Linux, you need CUDA® 11.2 or newer previously installed.
CUDA® itself would require a set of specific GPU drivers. Please follow CUDA® installation procedure in the NVIDIA® [web](https://www.nvidia.com/drivers).

If you want to install our GPU supported simulators, you have to install this other package:

```bash
pip install qiskit-aer-gpu
```

The package above is for CUDA&reg 12, so if your system has CUDA® 11 installed, install separate package:
```bash
pip install qiskit-aer-gpu-cu11
```

This will overwrite your current `qiskit-aer` package installation giving you
the same functionality found in the canonical `qiskit-aer` package, pl

qiskit, simulator, quantum computing, backend


Summary: 快速的数学公式手写插入工具（使用了 Mathpix API）

#  ![icon.ico](assets/icon.ico) Quick Math

## 📝 介绍
顾名思义，Quick Math 是用于快速输入数学公式的一个工具。

在主界面是一个画板，你可以在上边用鼠标、触摸屏、手写笔写出数学公式，然后点击识别按钮或者按下回车键，你写的公式图片就会被上传到 Mathpix 识别，然后会自动复制返回的 Latex 公式。

它是开源的，你可以免费使用它。下载安装请到 [Github releases](https://github.com/HaujetZhao/QuickMath/releases) 或者  [Gitee releases](https://gitee.com/haujet/QuickMath/releases) 界面。

目前在两个仓库更新：

- https://github.com/HaujetZhao/QuickMath
- https://gitee.com/haujet/QuickMath

使用界面：

![image-20200904070647991](assets/image-20200904070647991.png)

![image-20200904075335241](assets/image-20200904075335241.png)

## 🔮 使用说明

首先本软件识别数学公式使用的是 Mathpix 在线服务的 API。

有两种方式：

* 第一种，是使用自己的 API。你需要到 [Mathpix 官网](https://mathpix.com/ocr) 申请一个 Mathpix 账号，然后开通一个 OCR API 。

    开通 API 需要绑定信用卡，支持银联，绑定的时候会扣费1美元。

    Mathpix Api 的价格是：每个月前1000次免费，第 1-100K 次每次请求 0.004美元（约合人民币 0.028 元），第 100K-300K 次每次请求 0.002美元，第 300k 次这后每次请求 0.001美元，如果超过了第1000次，自动从信用卡扣费。你可以从官网页面看到这个月已经使用多少次。Quick Math 本身也提供了 API 使用次数统计的功能。

    申请完 API 后，回到软件在设置界面填入，就可以使用了。

* 第二种是使用 LatexLive。[LatexLive](https://latexlive.com) 是 B 站科普 UP 主 [@妈咪说MommyTalk](https://space.bilibili.com/223146252/) 搭建的一个 Latex 数学公式编辑、识别网站，也使用了 Mathpix 的 API，不过 API 费用都是 [@妈咪说MommyTalk](https://space.bilibili.com/223146252/) 自个替用户掏了。我在 Quick Math 里面加入了 LatexLive 的页面，同时也加入了使用 LatexLive 图片接口进行识别的功能，你只要在设置界面选择**使用 LatexLive 识别** 就可以免费识别你的手写公式了。不过请尊重  [@妈咪说MommyTalk](https://space.bilibili.com/223146252/) 自己掏钱为普通人提供便利的初心，不要滥用 LatexLive，你的每一次使用，都是有 UP 主在为你掏钱给 Mathpix，都是在白嫖 UP 的钱包。

所以我的建议是：先自己注册一个 Mathpix 的 API，使用自己的 1000 次每月的免费额度，不够了再使用 LatexLive 的方法。

在主界面是一个画板，你可以在上边用鼠标、触摸屏、手写笔写出数学公式，然后点击识别按钮或者按下回车键，你写的公式图片就会被上传到 Mathpix 识别，然后会自动复制返回的 Latex 公式。

## 🔨 参与贡献

作者只有 Win10 64 位系统，有空了发一个打包版本，不过还是建议使用 pip 安装。如果你用的是其它系统电脑，比如 windows 32 位、MacOS、Linux，你可以参与志愿打包。

只要安装上 requirements.txt 中的 python 依赖包，确保源码能跑起来，再用 pyinstaller 将 QuickHand.py 打包

再将：

- `misc` 文件夹
- `icon.ico` 文件
- `sponsor.jpg` 文件
- `style.css` 文件

都复制到打包出的 QuickMath 文件夹根目录，再打包成压缩包，即可。

Linux 和 MacOS 用户可能还需要将打包出的 QuickMath 文件夹根目录内的可执行文件加

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


Summary: Compile SCSS files to valid Qt stylesheets.

# QtSASS: Compile SCSS files to Qt stylesheets

[![License - MIT](https://img.shields.io/github/license/spyder-ide/qtsass.svg)](./LICENSE.txt)
[![OpenCollective Backers](https://opencollective.com/spyder/backers/badge.svg?color=blue)](#backers)
[![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>
[![Github build status](https://github.com/spyder-ide/qtsass/workflows/Tests/badge.svg)](https://github.com/spyder-ide/qtsass/actions)
[![Codecov coverage](https://img.shields.io/codecov/c/github/spyder-ide/qtsass/master.svg)](https://codecov.io/gh/spyder-ide/qtsass)
[![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/spyder-ide/qtsass/badges/quality-score.png?b=master)](https://scrutinizer-ci.com/g/spyder-ide/qtsass/?branch=master)

*Copyright © 2015 Yann Lanthony*

*Copyright © 2017–2018 Spyder Project Contributors*

## Overview

[SASS](http://sass-lang.com/) brings countless amazing features to CSS.
Besides being used in web development, CSS is also the way to stylize Qt-based desktop applications.
However, Qt's CSS has a few variations that prevent the direct use of SASS compiler.

The purpose of this tool is to fill the gap between SASS and Qt-CSS by handling those variations.

## Qt's CSS specificities

The goal of QtSASS is to be able to generate a Qt-CSS stylesheet based on a 100% valid SASS file.
This is how it deals with Qt's specifics and how you should modify your CSS stylesheet to use QtSASS.

#### "!" in selectors
Qt allows to define the style of a widget according to its states, like this:

```css
QLineEdit:enabled {
...
}
```

However, a "not" state is problematic because it introduces an exclamation mark in the selector's name, which is not valid SASS/CSS:

```css
QLineEdit:!editable {
...
}
```

QtSASS allows "!" in selectors' names; the SASS file is preprocessed and any occurence of `:!` is replaced by `:_qnot_` (for "Qt not").
However, using this feature

Topic :: Software Development :: Build Tools

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


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>


Summary: Fundamental package for array computing in Python

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

NumPy is the fundamental package for scientific computing with Python.

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

It provides:

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

Testing:

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

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

Programming Language :: Python :: Implementation :: CPython


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"

Intended Audience :: Information Technology

Topic :: Scientific/Engineering :: Artificial Intelligence

Topic :: Scientific/Engineering :: Human Machine Interfaces

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


Summary: Python package for creating and manipulating graphs and networks

NetworkX
========

.. image::
    https://github.com/networkx/networkx/actions/workflows/test.yml/badge.svg?branch=main
    :target: https://github.com/networkx/networkx/actions/workflows/test.yml

.. image::
    https://img.shields.io/pypi/v/networkx.svg?
    :target: https://pypi.python.org/pypi/networkx

.. image::
    https://img.shields.io/pypi/l/networkx.svg?
    :target: https://github.com/networkx/networkx/blob/main/LICENSE.txt

.. image::
    https://img.shields.io/pypi/pyversions/networkx.svg?
    :target: https://pypi.python.org/pypi/networkx

.. image::
    https://img.shields.io/github/labels/networkx/networkx/good%20first%20issue?color=green&label=contribute
    :target: https://github.com/networkx/networkx/contribute

.. image::
    https://insights.linuxfoundation.org/api/badge/health-score?project=networkx
    :target: https://insights.linuxfoundation.org/project/networkx

NetworkX is a Python package for the creation, manipulation,
and study of the structure, dynamics, and functions
of complex networks.

- **Website (including documentation):** https://networkx.org
- **Mailing list:** https://groups.google.com/forum/#!forum/networkx-discuss
- **Source:** https://github.com/networkx/networkx
- **Bug reports:** https://github.com/networkx/networkx/issues
- **Report a security vulnerability:** https://tidelift.com/security
- **Tutorial:** https://networkx.org/documentation/latest/tutorial.html
- **GitHub Discussions:** https://github.com/networkx/networkx/discussions
- **Discord (Scientific Python) invite link:** https://discord.com/invite/vur45CbwMz
- **NetworkX meetings calendar (open to all):** https://scientific-python.org/calendars/networkx.ics

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

Find the shortest path between two nodes in an undirected graph:

.. code:: pycon

    >>> import networkx as nx
    >>> G = nx.Graph()
    >>> G.add_edge("A", "B", weight=4)
    >>> G.add_edge("B", "D", weight=2)
    >>> G.add_edge("A", "C", weight=3)
    >>> G.add_edge("

pydata-sphinx-theme>=0.16; extra == "doc"

Topic :: Scientific/Engineering :: Bio-Informatics

Topic :: Scientific/Engineering :: Mathematics

Topic :: Scientific/Engineering :: Physics

Networks, Graph Theory, Mathematics, network, graph, discrete mathematics, math


Summary: Patch asyncio to allow nested event loops

|Build| |Status| |PyPiVersion| |License| |Downloads|

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

By design asyncio `does not allow <https://github.com/python/cpython/issues/66435>`_
its event loop to be nested. This presents a practical problem:
When in an environment where the event loop is
already running it's impossible to run tasks and wait
for the result. Trying to do so will give the error
"``RuntimeError: This event loop is already running``".

The issue pops up in various environments, such as web servers,
GUI applications and in Jupyter notebooks.

This module patches asyncio to allow nested use of ``asyncio.run`` and
``loop.run_until_complete``.

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

.. code-block::

    pip3 install nest_asyncio

Python 3.5 or higher is required.

Usage
-----

.. code-block:: python

    import nest_asyncio
    nest_asyncio.apply()

Optionally the specific loop that needs patching can be given
as argument to ``apply``, otherwise the current event loop is used.
An event loop can be patched whether it is already running
or not. Only event loops from asyncio can be patched;
Loops from other projects, such as uvloop or quamash,
generally can't be patched.

.. |Build| image:: https://github.com/erdewit/nest_asyncio/actions/workflows/test.yml/badge.svg?branche=master
   :alt: Build
   :target: https://github.com/erdewit/nest_asyncio/actions

.. |PyPiVersion| image:: https://img.shields.io/pypi/v/nest_asyncio.svg
   :alt: PyPi
   :target: https://pypi.python.org/pypi/nest_asyncio

.. |Status| image:: https://img.shields.io/badge/status-stable-green.svg
   :alt:

.. |License| image:: https://img.shields.io/badge/license-BSD-blue.svg
   :alt:

.. |Downloads| image:: https://static.pepy.tech/badge/nest-asyncio/month
   :alt: Number of downloads
   :target: https://pepy.tech/project/nest-asyncio

Programming Language :: Python :: 3 :: Only


Summary: compiling Python code using LLVM

*****
Numba
*****

.. image:: https://img.shields.io/badge/discuss-on%20discourse-blue
   :target: https://numba.discourse.group/
   :alt: Discourse

.. image:: https://zenodo.org/badge/doi/10.5281/zenodo.4343230.svg
   :target: https://doi.org/10.5281/zenodo.4343230
   :alt: Zenodo

.. image:: https://img.shields.io/pypi/v/numba.svg
   :target: https://pypi.python.org/pypi/numba/
   :alt: PyPI

.. image:: https://dev.azure.com/numba/numba/_apis/build/status/numba.numba?branchName=main
    :target: https://dev.azure.com/numba/numba/_build/latest?definitionId=1?branchName=main
    :alt: Azure Pipelines

A Just-In-Time Compiler for Numerical Functions in Python
#########################################################

Numba is an open source, NumPy-aware optimizing compiler for Python sponsored
by Anaconda, Inc.  It uses the LLVM compiler project to generate machine code
from Python syntax.

Numba can compile a large subset of numerically-focused Python, including many
NumPy functions.  Additionally, Numba has support for automatic
parallelization of loops, generation of GPU-accelerated code, and creation of
ufuncs and C callbacks.

For more information about Numba, see the Numba homepage:
https://numba.pydata.org and the online documentation:
https://numba.readthedocs.io/en/stable/index.html

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

Please follow the instructions:

https://numba.readthedocs.io/en/stable/user/installing.html

Demo
====

Please have a look and the demo notebooks via the mybinder service:

https://mybinder.org/v2/gh/numba/numba-examples/master?filepath=notebooks

Contact
=======

Numba has a discourse forum for discussions:

* https://numba.discourse.group

Topic :: Software Development :: Compilers


natsort
=======

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

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

.. image:: https://img.shields.io/pypi/l/natsort.svg
    :target: https://github.com/SethMMorton/natsort/blob/main/LICENSE

.. image:: https://github.com/SethMMorton/natsort/workflows/Tests/badge.svg
    :target: https://github.com/SethMMorton/natsort/actions

.. image:: https://codecov.io/gh/SethMMorton/natsort/branch/main/graph/badge.svg
    :target: https://codecov.io/gh/SethMMorton/natsort

.. image:: https://img.shields.io/pypi/dw/natsort.svg
    :target: https://pypi.org/project/natsort/

Simple yet flexible natural sorting in Python.

    - Source Code: https://github.com/SethMMorton/natsort
    - Downloads: https://pypi.org/project/natsort/
    - Documentation: https://natsort.readthedocs.io/

      - `Examples and Recipes`_
      - `How Does Natsort Work?`_
      - `API`_

    - `Quick Description`_
    - `Quick Examples`_
    - `FAQ`_
    - `Requirements`_
    - `Optional Dependencies`_
    - `Installation`_
    - `How to Run Tests`_
    - `How to Build Documentation`_
    - `Dropped Deprecated APIs`_
    - `History`_

**NOTE**: Please see the `Dropped Deprecated APIs`_ section for changes.

Quick Description
-----------------

When you try to sort a list of strings that contain numbers, the normal python
sort algorithm sorts lexicographically, so you might not get the results that
you expect:

.. code-block:: pycon

    >>> a = ['2 ft 7 in', '1 ft 5 in', '10 ft 2 in', '2 ft 11 in', '7 ft 6 in']
    >>> sorted(a)
    ['1 ft 5 in', '10 ft 2 in', '2 ft 11 in', '2 ft 7 in', '7 ft 6 in']

Notice that it has the order ('1', '10', '2') - this is because the list is
being sorted in lexicographical order, which sorts numbers like you would
letters (i.e. 'b', 'ba', 'c').

`natsort`_ provides a function `natsorted()`_ that helps sort lists
"n

fastnumbers (>=2.0.0) ; extra == 'fast'
PyICU (>=1.0.0) ; extra == 'icu'

Intended Audience :: System Administrators

Topic :: Scientific/Engineering :: Information Analysis


Summary: A network address manipulation library for Python

netaddr
=======

.. image:: https://codecov.io/gh/netaddr/netaddr/branch/master/graph/badge.svg
   :target: https://codecov.io/gh/netaddr/netaddr
.. image:: https://github.com/netaddr/netaddr/workflows/CI/badge.svg
   :target: https://github.com/netaddr/netaddr/actions?query=workflow%3ACI+branch%3Amaster
.. image:: https://img.shields.io/pypi/v/netaddr.svg
   :target: https://pypi.org/project/netaddr/
.. image:: https://img.shields.io/pypi/pyversions/netaddr.svg
   :target: pypi.python.org/pypi/netaddr

A Python library for representing and manipulating network addresses.

Provides support for:

Layer 3 addresses

-  IPv4 and IPv6 addresses, subnets, masks, prefixes
-  iterating, slicing, sorting, summarizing and classifying IP networks
-  dealing with various ranges formats (CIDR, arbitrary ranges and
   globs, nmap)
-  set based operations (unions, intersections etc) over IP addresses
   and subnets
-  parsing a large variety of different formats and notations
-  looking up IANA IP block information
-  generating DNS reverse lookups
-  supernetting and subnetting

Layer 2 addresses

-  representation and manipulation MAC addresses and EUI-64 identifiers
-  looking up IEEE organisational information (OUI, IAB)
-  generating derived IPv6 addresses

| Documentation: https://netaddr.readthedocs.io/en/latest/

| Source code repository: https://github.com/netaddr/netaddr/

PyPI page: https://pypi.org/project/netaddr/

Share and enjoy!

"David P. D. Moss" <josiah_carberry@brown.edu>, Stefan Nordhausen <stefan.nordhausen@immobilienscout24.de>

Development Status :: 5 - Production/Stable

Intended Audience :: Telecommunications Industry

Topic :: Internet :: WWW/HTTP :: Indexing/Search

Topic :: Internet :: WWW/HTTP :: Site Management

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

Topic :: Software Development :: Quality Assurance

Topic :: Software Development :: Testing :: Traffic Generation

Topic :: System :: Distributed Computing

Topic :: System :: Networking :: Firewalls

Topic :: System :: Networking :: Monitoring

Topic :: System :: Networking :: Time Synchronization

Topic :: System :: Software Distribution

Topic :: System :: Systems Administration

Networking, Systems Administration, IANA, IEEE, CIDR, IP, IPv4, IPv6, CIDR, EUI, MAC, MAC-48, EUI-48, EUI-64


Summary: nanobind: tiny and efficient C++/Python bindings

![nanobind logo](
https://github.com/wjakob/nanobind/raw/master/docs/images/logo.jpg?raw=True)

_nanobind_ is a small binding library that exposes C++ types in Python and
vice versa. It is reminiscent of
[Boost.Python](https://www.boost.org/doc/libs/1_64_0/libs/python/doc/html)
and [pybind11](http://github.com/pybind/pybind11) and uses near-identical
syntax. In contrast to these existing tools, nanobind is more efficient:
bindings compile in a shorter amount of time, produce smaller binaries, and
have better runtime performance.

More concretely,
[benchmarks](https://nanobind.readthedocs.io/en/latest/benchmark.html) show up
to **~4× faster** compile time, **~5× smaller** binaries, and **~10× lower**
runtime overheads compared to pybind11. nanobind also outperforms Cython in
important metrics (**3-12×** binary size reduction, **1.6-4×** compilation time
reduction, similar runtime performance).

Please see the following links for tutorial and reference documentation in
[HTML](https://nanobind.readthedocs.io/en/latest/) and
[PDF](https://nanobind.readthedocs.io/_/downloads/en/latest/pdf/) formats.

Programming Language :: Python :: 3 :: Only

Programming Language :: Python :: Implementation :: CPython

Programming Language :: Python :: Implementation :: PyPy


Summary: nose extends unittest to make testing easier

nose extends the test loading and running features of unittest, making
    it easier to write, find and run tests.

    By default, nose will run tests in files or directories under the current
    working directory whose names include "test" or "Test" at a word boundary
    (like "test_this" or "functional_test" or "TestClass" but not
    "libtest"). Test output is similar to that of unittest, but also includes
    captured stdout output from failing tests, for easy print-style debugging.

    These features, and many more, are customizable through the use of
    plugins. Plugins included with nose provide support for doctest, code
    coverage and profiling, flexible attribute-based test selection,
    output capture and more. More information about writing plugins may be
    found on in the nose API documentation, here:
    http://readthedocs.org/docs/nose/

    If you have recently reported a bug marked as fixed, or have a craving for
    the very latest, you may want the development version instead:
    https://github.com/nose-devs/nose/tarball/master#egg=nose-dev

Development Status :: 5 - Production/Stable

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

test unittest doctest automatic discovery


Summary: A Python library to read/write Excel 2010 xlsx/xlsm files

.. image:: https://coveralls.io/repos/bitbucket/openpyxl/openpyxl/badge.svg?branch=default
    :target: https://coveralls.io/bitbucket/openpyxl/openpyxl?branch=default
    :alt: coverage status

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

openpyxl is a Python library to read/write Excel 2010 xlsx/xlsm/xltx/xltm files.

It was born from lack of existing library to read/write natively from Python
the Office Open XML format.

All kudos to the PHPExcel team as openpyxl was initially based on PHPExcel.

Security
--------

By default openpyxl does not guard against quadratic blowup or billion laughs
xml attacks. To guard against these attacks install defusedxml.

Mailing List
------------

The user list can be found on http://groups.google.com/group/openpyxl-users

Sample code::

    from openpyxl import Workbook
    wb = Workbook()

    # grab the active worksheet
    ws = wb.active

    # Data can be assigned directly to cells
    ws['A1'] = 42

    # Rows can also be appended
    ws.append([1, 2, 3])

    # Python types will automatically be converted
    import datetime
    ws['A2'] = datetime.datetime.now()

    # Save the file
    wb.save("sample.xlsx")

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

The documentation is at: https://openpyxl.readthedocs.io

* installation methods
* code examples
* instructions for contributing

Release notes: https://openpyxl.readthedocs.io/en/stable/changes.html

Operating System :: Microsoft :: Windows


Summary: Wrapper package for OpenCV python bindings.

[![Downloads](https://static.pepy.tech/badge/opencv-python)](http://pepy.tech/project/opencv-python)

### Keep OpenCV Free

OpenCV is raising funds to keep the library free for everyone, and we need the support of the entire community to do it. [Donate to OpenCV on Github](https://github.com/sponsors/opencv) to show your support.

- [OpenCV on Wheels](#opencv-on-wheels)
  - [Installation and Usage](#installation-and-usage)
- [Frequently Asked Questions](#frequently-asked-questions)
- [Documentation for opencv-python](#documentation-for-opencv-python)
  - [CI build process](#ci-build-process)
  - [Manual builds](#manual-builds)
    - [Manual debug builds](#manual-debug-builds)
    - [Source distributions](#source-distributions)
  - [Licensing](#licensing)
  - [Versioning](#versioning)
  - [Releases](#releases)
  - [Development builds](#development-builds)
  - [Manylinux wheels](#manylinux-wheels)
  - [Supported Python versions](#supported-python-versions)
  - [Backward compatibility](#backward-compatibility)

## OpenCV on Wheels

Pre-built CPU-only OpenCV packages for Python.

Check the manual build section if you wish to compile the bindings from source to enable additional modules such as CUDA.

### Installation and Usage

1. If you have previous/other manually installed (= not installed via ``pip``) version of OpenCV installed (e.g. cv2 module in the root of Python's site-packages), remove it before installation to avoid conflicts.
2. Make sure that your `pip` version is up-to-date (19.3 is the minimum supported version): `pip install --upgrade pip`. Check version with `pip -V`. For example Linux distributions ship usually with very old `pip` versions which cause a lot of unexpected problems especially with the `manylinux` format.
3. Select the correct package for your environment:

    There are four different packages (see options 1, 2, 3 and 4 below) and you should **SELECT ONLY ONE OF THEM**. Do not install multiple different

numpy<2.0; python_version < "3.9"
numpy>=2; python_version >= "3.9"

Intended Audience :: Information Technology

License :: OSI Approved :: Apache Software License

Topic :: Scientific/Engineering :: Image Recognition


Summary: Path optimization of einsum functions.

# Optimized Einsum

[![Tests](https://github.com/dgasmith/opt_einsum/actions/workflows/Tests.yml/badge.svg)](https://github.com/dgasmith/opt_einsum/actions/workflows/Tests.yml)
[![codecov](https://codecov.io/gh/dgasmith/opt_einsum/branch/master/graph/badge.svg)](https://codecov.io/gh/dgasmith/opt_einsum)
[![Anaconda-Server Badge](https://anaconda.org/conda-forge/opt_einsum/badges/version.svg)](https://anaconda.org/conda-forge/opt_einsum)
[![PyPI](https://img.shields.io/pypi/v/opt_einsum.svg)](https://pypi.org/project/opt-einsum/#description)
[![PyPIStats](https://img.shields.io/pypi/dm/opt_einsum)](https://pypistats.org/packages/opt-einsum)
[![Documentation Status](https://github.com/dgasmith/opt_einsum/actions/workflows/Docs.yaml/badge.svg)](https://dgasmith.github.io/opt_einsum/)
[![DOI](https://joss.theoj.org/papers/10.21105/joss.00753/status.svg)](https://doi.org/10.21105/joss.00753)

## Optimized Einsum: A tensor contraction order optimizer

Optimized einsum can significantly reduce the overall execution time of einsum-like expressions (e.g.,
[`np.einsum`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.einsum.html),
[`dask.array.einsum`](https://docs.dask.org/en/latest/array-api.html#dask.array.einsum),
[`pytorch.einsum`](https://pytorch.org/docs/stable/torch.html#torch.einsum),
[`tensorflow.einsum`](https://www.tensorflow.org/api_docs/python/tf/einsum),
)
by optimizing the expression's contraction order and dispatching many
operations to canonical BLAS, cuBLAS, or other specialized routines.

Optimized
einsum is agnostic to the backend and can handle NumPy, Dask, PyTorch,
Tensorflow, CuPy, Sparse, Theano, JAX, and Autograd arrays as well as potentially
any library which conforms to a standard API. See the
[**documentation**](https://dgasmith.github.io/opt_einsum/) for more
information.

## Example usage

The [`opt_einsum.contract`](https://dgasmith.github.io/opt_einsum/api_reference#opt_einsumcontract)
function can often act as a drop-in replacemen

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


OAuthLib - Python Framework for OAuth1 & OAuth2
===============================================

*A generic, spec-compliant, thorough implementation of the OAuth request-signing
logic for Python 3.8+*

.. image:: https://github.com/oauthlib/oauthlib/actions/workflows/python-build.yml/badge.svg
  :target: https://github.com/oauthlib/oauthlib/actions
  :alt: GitHub Actions
.. image:: https://coveralls.io/repos/oauthlib/oauthlib/badge.svg?branch=master
  :target: https://coveralls.io/r/oauthlib/oauthlib
  :alt: Coveralls
.. image:: https://img.shields.io/pypi/pyversions/oauthlib.svg
  :target: https://pypi.org/project/oauthlib/
  :alt: Download from PyPI
.. image:: https://img.shields.io/pypi/l/oauthlib.svg
  :target: https://pypi.org/project/oauthlib/
  :alt: License
.. image:: https://app.fossa.io/api/projects/git%2Bgithub.com%2Foauthlib%2Foauthlib.svg?type=shield
   :target: https://app.fossa.io/projects/git%2Bgithub.com%2Foauthlib%2Foauthlib?ref=badge_shield
   :alt: FOSSA Status
.. image:: https://img.shields.io/readthedocs/oauthlib.svg
  :target: https://oauthlib.readthedocs.io/en/latest/index.html
  :alt: Read the Docs
.. image:: https://badges.gitter.im/oauthlib/oauthlib.svg
  :target: https://gitter.im/oauthlib/Lobby
  :alt: Chat on Gitter

.. image:: https://raw.githubusercontent.com/oauthlib/oauthlib/8d71b161fd145d11c40d55c9ab66ac134a303253/docs/logo/oauthlib-banner-700x192.png
  :target: https://github.com/oauthlib/oauthlib/
  :alt: OAuth + Python = OAuthlib Python Framework

OAuth often seems complicated and difficult-to-implement. There are several
prominent libraries for handling OAuth requests, but they all suffer from one or
both of the following:

1. They predate the `OAuth 1.0 spec`_, AKA RFC 5849.
2. They predate the `OAuth 2.0 spec`_, AKA RFC 6749.
3. They assume the usage of a specific HTTP request library.

.. _`OAuth 1.0 spec`: https://tools.ietf.org/html/rfc5849
.. _`OAuth 2.0 spec`: https://tools.ietf.org/html/rfc6749

OAuthLib is a framewor

cryptography>=3.0.0; extra == "signedtoken"

Programming Language :: Python :: Implementation


Summary: Fast, correct Python JSON library supporting dataclasses, datetimes, and numpy

# orjson

orjson is a fast, correct JSON library for Python. It
[benchmarks](https://github.com/ijl/orjson?tab=readme-ov-file#performance) as the fastest Python
library for JSON and is more correct than the standard json library or other
third-party libraries. It serializes
[dataclass](https://github.com/ijl/orjson?tab=readme-ov-file#dataclass),
[datetime](https://github.com/ijl/orjson?tab=readme-ov-file#datetime),
[numpy](https://github.com/ijl/orjson?tab=readme-ov-file#numpy), and
[UUID](https://github.com/ijl/orjson?tab=readme-ov-file#uuid) instances natively.

[orjson.dumps()](https://github.com/ijl/orjson?tab=readme-ov-file#serialize) is
something like 10x as fast as `json`, serializes
common types and subtypes, has a `default` parameter for the caller to specify
how to serialize arbitrary types, and has a number of flags controlling output.

[orjson.loads()](https://github.com/ijl/orjson?tab=readme-ov-file#deserialize)
is something like 2x as fast as `json`, and is strictly compliant with UTF-8 and
RFC 8259 ("The JavaScript Object Notation (JSON) Data Interchange Format").

Reading from and writing to files, line-delimited JSON files, and so on is
not provided by the library.

orjson supports CPython 3.10, 3.11, 3.12, 3.13, 3.14, and 3.15.

It distributes amd64/x86_64/x64, i686/x86, aarch64/arm64/armv8, arm7,
ppc64le/POWER8, and s390x wheels for Linux, amd64 and aarch64 wheels
for macOS, and amd64, i686, and aarch64 wheels for Windows.

Wheels published to PyPI for amd64 run on x86-64-v1 (2003)
or later, but will at runtime use AVX-512 if available for a
significant performance benefit; aarch64 wheels run on ARMv8-A (2011) or
later.

orjson does not and will not support PyPy, embedded Python builds for
Android/iOS, or PEP 554 subinterpreters.

orjson may support PEP 703 free-threading when it is stable.

Releases follow semantic versioning and serializing a new object type
without an opt-in flag is considered a breaking change.

orjson contains source code lic

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


Summary: A flexible configuration library

# OmegaConf
|  | Description |
| --- | --- |
| Project | [![PyPI version](https://badge.fury.io/py/omegaconf.svg)](https://badge.fury.io/py/omegaconf)[![Downloads](https://pepy.tech/badge/omegaconf/month)](https://pepy.tech/project/omegaconf?versions=1.4.*&versions=2.0.*&versions=2.1.*)![PyPI - Python Version](https://img.shields.io/pypi/pyversions/omegaconf.svg) |
| Code quality| [![CircleCI](https://img.shields.io/circleci/build/github/omry/omegaconf?logo=s&token=5de2f8dc2a0dd78438520575431aa533150806e3)](https://circleci.com/gh/omry/omegaconf)[![Coverage Status](https://coveralls.io/repos/github/omry/omegaconf/badge.svg)](https://coveralls.io/github/omry/omegaconf)[![Total alerts](https://img.shields.io/lgtm/alerts/g/omry/omegaconf.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/omry/omegaconf/alerts/)[![Language grade: Python](https://img.shields.io/lgtm/grade/python/g/omry/omegaconf.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/omry/omegaconf/context:python)|
| Docs and support |[![Documentation Status](https://readthedocs.org/projects/omegaconf/badge/?version=2.0_branch)](https://omegaconf.readthedocs.io/en/2.1_branch/)[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/omry/omegaconf/master?filepath=docs%2Fnotebook%2FTutorial.ipynb)|

OmegaConf is a hierarchical configuration system, with support for merging configurations from multiple sources (YAML config files, dataclasses/objects and CLI arguments)
providing a consistent API regardless of how the configuration was created.

## Releases

### Stable (2.3)
OmegaConf 2.3 is the current stable version.
* [What's new](https://github.com/omry/omegaconf/releases/tag/v2.3.0)
* [Documentation](https://omegaconf.readthedocs.io/en/2.3_branch/)
* [Source code](https://github.com/omry/omegaconf/tree/2.3_branch)

Install with `pip install --upgrade omegaconf`

### Previous release (2.2)

* [What's new](https://github.com/omry/omegaconf/releases/tag/v2.1.1)
* [Documentation](h

License :: OSI Approved :: BSD License
Operating System :: OS Independent
Programming Language :: Python :: 3.10
Programming Language :: Python :: 3.11
Programming Language :: Python :: 3.6
Programming Language :: Python :: 3.7
Programming Language :: Python :: 3.8
Programming Language :: Python :: 3.9


Summary: A hyperparameter optimization framework

# Optuna: A hyperparameter optimization framework

[![Python](https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12%20%7C%203.13%20%7C%203.14-blue)](https://www.python.org)
[![pypi](https://img.shields.io/pypi/v/optuna.svg)](https://pypi.python.org/pypi/optuna)
[![conda](https://img.shields.io/conda/vn/conda-forge/optuna.svg)](https://anaconda.org/conda-forge/optuna)
[![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/optuna/optuna)
[![Read the Docs](https://readthedocs.org/projects/optuna/badge/?version=stable)](https://optuna.readthedocs.io/en/stable/)

:link: [**Website**](https://optuna.org/)
| :page_with_curl: [**Docs**](https://optuna.readthedocs.io/en/stable/)
| :gear: [**Install Guide**](https://optuna.readthedocs.io/en/stable/installation.html)
| :pencil: [**Tutorial**](https://optuna.readthedocs.io/en/stable/tutorial/index.html)
| :bulb: [**Examples**](https://github.com/optuna/optuna-examples)
| [**Twitter**](https://twitter.com/OptunaAutoML)
| [**LinkedIn**](https://www.linkedin.com/showcase/optuna/)
| [**Medium**](https://medium.com/optuna)

*Optuna* is an automatic hyperparameter optimization software framework, particularly designed
for machine learning. It features an imperative, *define-by-run* style user API. Thanks to our
*define-by-run* API, the code written with Optuna enjoys high modularity, and the user of
Optuna can dynamically construct the search spaces for the hyperparameters.

## :loudspeaker: News

* **Mar 16, 2026**: Optuna 4.8.0 is out! Check out [the release note](https://github.com/optuna/optuna/releases/tag/v4.8.0) for details.
* **Jan 19, 2026**: Optuna 4.7.0 is out! Check out [the release note](https://github.com/optuna/optuna/releases/tag/v4.7.0) for details.
* **Nov

kaleido!=0.2.1.post1,<0.4; extra == "document"

sphinx-notfound-page; extra == "document"

sphinx_rtd_theme>=1.2.0; extra == "document"

google-cloud-storage; extra == "optional"

scikit-learn>=0.24.2; extra == "optional"

Topic :: Scientific/Engineering :: Artificial Intelligence

Topic :: Scientific/Engineering :: Mathematics

Topic :: Software Development :: Libraries


Summary: OpenTelemetry Python API

OpenTelemetry Python API
============================================================================

|pypi|

.. |pypi| image:: https://badge.fury.io/py/opentelemetry-api.svg
   :target: https://pypi.org/project/opentelemetry-api/

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

::

    pip install opentelemetry-api

References
----------

* `OpenTelemetry Project <https://opentelemetry.io/>`_


Summary: Oslo Configuration API

==========================
Oslo Configuration Library
==========================

.. image:: https://governance.openstack.org/tc/badges/oslo.config.svg

.. Change things from this point on

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

.. image:: https://img.shields.io/pypi/dm/oslo.config.svg
    :target: https://pypi.org/project/oslo.config/
    :alt: Downloads

The Oslo configuration API supports parsing command line arguments and
.ini style configuration files.

* License: Apache License, Version 2.0
* Documentation: https://docs.openstack.org/oslo.config/latest/
* Source: https://opendev.org/openstack/oslo.config/
* Bugs: https://bugs.launchpad.net/oslo.config
* Release notes:  https://docs.openstack.org/releasenotes/oslo.config/

rst2txt>=1.1.0; extra == "rst-generator"


Summary: ObsPy - a Python framework for seismological observatories.

ObsPy is an open-source project dedicated to provide a Python framework for
processing seismological data. It provides parsers for common file formats,
clients to access data centers and seismological signal processing routines
which allow the manipulation of seismological time series (see Beyreuther et
al. 2010, Megies et al. 2011).

The goal of the ObsPy project is to facilitate rapid application development
for seismology.

For more information visit https://www.obspy.org.

:copyright:
    The ObsPy Development Team (devs@obspy.org)
:license:
    GNU Lesser General Public License, Version 3
    (https://www.gnu.org/copyleft/lesser.html)

GNU Lesser General Public License, Version 3 (LGPLv3)

numpy>=1.21
scipy>=1.7
matplotlib>=3.3
lxml
setuptools
sqlalchemy>=1.4
decorator
requests
packaging; extra == "tests"
pyproj; extra == "tests"
pytest; extra == "tests"
pytest-json-report; extra == "tests"
geographiclib; extra == "geo"
cartopy; extra == "imaging"
pyshp; extra == "io-shapefile"
packaging; extra == "all"
pyproj; extra == "all"
pytest; extra == "all"
pytest-json-report; extra == "all"
geographiclib; extra == "all"
cartopy; extra == "all"
pyshp; extra == "all"

License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)

Topic :: Scientific/Engineering :: Physics

ALSEP, ArcLink, array, array analysis, ASC, beachball, beamforming, cross correlation, CYBERSHAKE, database, dataless, Dataless SEED, DMX, earthquakes, EarthScope, Earthworm, EIDA, envelope, ESRI, events, FDSN, features, filter, focal mechanism, FOCMEC, GCF, GSE1, GSE2, hob, Tau-P, IASPEI, imaging, IMS, instrument correction, instrument simulation, IRIS, ISF, kinemetrics, KML, magnitude, MiniSEED, misfit, mopad, MSEED, NDK, NERA, NERIES, NonLinLoc, NLLOC, Nordic, NRL, observatory, ORFEUS, PDAS, picker, processing, PQLX, Q, real time, realtime, REFTEK, REFTEK130, RG-1.6, RT-130, RESP, response file, RT, SAC, SAGE, scardec, scml, sc3ml, SDS, SEED, SeedLink, SEG-2, SEG Y, SEISAN, Seismic Handler, seismology, seismogram, seismograms, shapefile, signal, slink, spectrogram, StationXML, taper, taup, travel time, trigger, VERCE, WAV, waveform, WaveServer, WaveServerV, WebDC, web service, WIN, Winston, XML-SEED, XSEED


Summary: Backported and Experimental Type Hints for Python 3.9+

# Typing Extensions

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

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

## Overview

The `typing_extensions` module serves two related purposes:

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

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

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

## Included items

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

## Contributing

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

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

Programming Language :: Python :: 3 :: Only

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


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


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

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

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

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

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

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

<!-- toc -->

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

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

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

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

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

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

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

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

Development Status :: 5 - Production/Stable


    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 :: System Administrators

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


Summary: Fast, Extensible Progress Meter

|Logo|

tqdm
====

|Py-Versions| |Versions| |Conda-Forge-Status| |Docker| |Snapcraft|

|Build-Status| |Coverage-Status| |Branch-Coverage-Status| |Codacy-Grade| |Libraries-Rank| |PyPI-Downloads|

|LICENCE| |OpenHub-Status| |colab-demo| |binder-demo| |awesome-python|

``tqdm`` derives from the Arabic word *taqaddum* (تقدّم) which can mean "progress,"
and is an abbreviation for "I love you so much" in Spanish (*te quiero demasiado*).

Instantly make your loops show a smart progress meter - just wrap any
iterable with ``tqdm(iterable)``, and you're done!

.. code:: python

    from tqdm import tqdm
    for i in tqdm(range(10000)):
        ...

``76%|████████████████████████        | 7568/10000 [00:33<00:10, 229.00it/s]``

``trange(N)`` can also be used as a convenient shortcut for
``tqdm(range(N))``.

|Screenshot|
    |Video| |Slides| |Merch|

It can also be executed as a module with pipes:

.. code:: sh

    $ seq 9999999 | tqdm --bytes | wc -l
    75.2MB [00:00, 217MB/s]
    9999999

    $ tar -zcf - docs/ | tqdm --bytes --total `du -sb docs/ | cut -f1` \
        > backup.tgz
     32%|██████████▍                      | 8.89G/27.9G [00:42<01:31, 223MB/s]

Overhead is low -- about 60ns per iteration (80ns with ``tqdm.gui``), and is
unit tested against performance regression.
By comparison, the well-established
`ProgressBar <https://github.com/niltonvolpato/python-progressbar>`__ has
an 800ns/iter overhead.

In addition to its low overhead, ``tqdm`` uses smart algorithms to predict
the remaining time and to skip unnecessary iteration displays, which allows
for a negligible overhead in most cases.

``tqdm`` works on any platform
(Linux, Windows, Mac, FreeBSD, NetBSD, Solaris/SunOS),
in any console or in a GUI, and is also friendly with IPython/Jupyter notebooks.

``tqdm`` does not require any dependencies (not even ``curses``!), just
Python and an environment supporting ``carriage return \r`` and
``line feed \n`` control characters.

**Featured Sponsors**

======== ======

colorama; platform_system == "Windows"
requests; extra == "discord"
envwrap; extra == "discord"
slack-sdk; extra == "slack"
envwrap; extra == "slack"
requests; extra == "telegram"
envwrap; extra == "telegram"
ipywidgets>=6; extra == "notebook"

Operating System :: Microsoft :: Windows

Operating System :: POSIX :: BSD :: FreeBSD

Operating System :: POSIX :: SunOS/Solaris

Programming Language :: Python :: Implementation :: IronPython

Programming Language :: Python :: Implementation :: PyPy

Topic :: Education :: Computer Aided Instruction (CAI)

Topic :: Software Development :: Build Tools

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

Topic :: Software Development :: Pre-processors

Topic :: Software Development :: User Interfaces

progressbar, progressmeter, progress, bar, meter, rate, eta, console, terminal, time


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

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

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

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

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

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

.. code-block:: python

    import asyncio
    import tornado

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

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

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

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

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

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

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

License :: OSI Approved :: Apache Software License

Programming Language :: Python :: Implementation :: CPython


Summary: An asynchronous networking framework written in Python

Twisted
#######

|gitter|_
|rtd|_
|pypi|_
|ci|_

For information on changes in this release, see the `NEWS <https://github.com/twisted/twisted/blob/trunk/NEWS.rst>`_ file.

Sponsors
--------

Twisted is an MIT-licensed open source project with its ongoing development made possible entirely by the support of community and these awesome sponsors.
If you'd like to join them, please consider `sponsoring Twisted's <https://docs.twisted.org/en/latest/development/sponsorship.html>`_ development.

|thinkst|_

|sftpplus|_

What is this?
-------------

Twisted is a Python event-based framework for internet applications.
It includes modules for many different purposes, including the following:

- ``twisted.web``: HTTP clients and servers, HTML templating, and a WSGI server
- ``twisted.conch``: SSHv2 and Telnet clients and servers and terminal emulators
- ``twisted.words``: Clients and servers for IRC, XMPP, and other IM protocols
- ``twisted.mail``: IMAPv4, POP3, SMTP clients and servers
- ``twisted.positioning``: Tools for communicating with NMEA-compatible GPS receivers
- ``twisted.names``: DNS client and tools for making your own DNS servers
- ``twisted.trial``: A unit testing framework that integrates well with Twisted-based code.

Twisted supports all major system event loops -- ``select`` (all platforms), ``poll`` (most POSIX platforms), ``epoll`` (Linux), ``kqueue`` (FreeBSD, macOS), IOCP (Windows), and various GUI event loops (GTK+2/3, Qt, wxWidgets).
Third-party reactors can plug into Twisted, and provide support for additional event loops.

Installing
----------

To install the latest version of Twisted using pip::

  $ pip install twisted

Additional instructions for installing this software are in `the installation instructions <https://docs.twisted.org/en/latest/installation.html>`_.

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

Twisted's documentation is available from the `Twisted Matrix Read The Docs website <https://docs.twisted.org/>`_.
This docum

Twisted Matrix Community <twisted@python.org>

appdirs>=1.4.0; extra == "all-non-platform"

bcrypt>=3.2.1; extra == "all-non-platform"

cryptography>=38; extra == "all-non-platform"

cython-test-exception-raiser<2,>=1.0.2; extra == "all-non-platform"

h2<5.0,>=3.2; extra == "all-non-platform"

httpx[http2]>=0.27; extra == "all-non-platform"

hypothesis>=6.56; extra == "all-non-platform"

priority<2.0,>=1.1.0; extra == "all-non-platform"

pyhamcrest>=2; extra == "all-non-platform"

pyopenssl>=25.2.0; extra == "all-non-platform"

pyserial>=3.0; extra == "all-non-platform"

pywin32!=226; platform_system == "Windows" and extra == "all-non-platform"

service-identity>=18.1.0; extra == "all-non-platform"

cython-test-exception-raiser<2,>=1.0.2; extra == "dev"

pydoctor~=25.4.0; extra == "dev-release"

sphinx-rtd-theme~=1.3; extra == "dev-release"

cryptography>=38; extra == "gtk-platform"

cython-test-exception-raiser<2,>=1.0.2; extra == "gtk-platform"

httpx[http2]>=0.27; extra == "gtk-platform"

hypothesis>=6.56; extra == "gtk-platform"

priority<2.0,>=1.1.0; extra == "gtk-platform"

pygobject; python_version >= "3.10" and extra == "gtk-platform"

pygobject<3.52.1; python_version < "3.10" and extra == "gtk-platform"

pyopenssl>=25.2.0; extra == "gtk-platform"

pywin32!=226; platform_system == "Windows" and extra == "gtk-platform"

service-identity>=18.1.0; extra == "gtk-platform"

appdirs>=1.4.0; extra == "macos-platform"

bcrypt>=3.2.1; extra == "macos-platform"

cryptography>=38; extra == "macos-platform"

cython-test-exception-raiser<2,>=1.0.2; extra == "macos-platform"

httpx[http2]>=0.27; extra == "macos-platform"

hypothesis>=6.56; extra == "macos-platform"

priority<2.0,>=1.1.0; extra == "macos-platform"

pyhamcrest>=2; extra == "macos-platform"

pyobjc-core>=12; python_version >= "3.10" and extra == "macos-platform"

pyobjc-framework-cfnetwork>=12; python_version >= "3.10" and extra == "macos-platform"

pyobjc-framework-cocoa>=12; python_version >= "3.10" and extra == "macos-platform"

pyopenssl>=25.2.0; extra == "macos-platform"

pyserial>=3.0; extra == "macos-platform"

pywin32!=226; platform_system == "Windows" and extra == "macos-platform"

service-identity>=18.1.0; extra == "macos-platform"

cython-test-exception-raiser<2,>=1.0.2; extra == "mypy"

pywin32!=226; platform_system == "Windows" and extra == "mypy"

service-identity>=18.1.0; extra == "mypy"

cryptography>=38; extra == "osx-platform"

cython-test-exception-raiser<2,>=1.0.2; extra == "osx-platform"

httpx[http2]>=0.27; extra == "osx-platform"

hypothesis>=6.56; extra == "osx-platform"

priority<2.0,>=1.1.0; extra == "osx-platform"

pyobjc-core>=12; python_version >= "3.10" and extra == "osx-platform"

pyobjc-framework-cfnetwork>=12; python_version >= "3.10" and extra == "osx-platform"

pyobjc-framework-cocoa>=12; python_version >= "3.10" and extra == "osx-platform"

pyopenssl>=25.2.0; extra == "osx-platform"

pywin32!=226; platform_system == "Windows" and extra == "osx-platform"

service-identity>=18.1.0; extra == "osx-platform"

pywin32!=226; platform_system == "Windows" and extra == "serial"

cython-test-exception-raiser<2,>=1.0.2; extra == "test"

service-identity>=18.1.0; extra == "tls"

appdirs>=1.4.0; extra == "windows-platform"

bcrypt>=3.2.1; extra == "windows-platform"

cryptography>=38; extra == "windows-platform"

cython-test-exception-raiser<2,>=1.0.2; extra == "windows-platform"

h2<5.0,>=3.2; extra == "windows-platform"

httpx[http2]>=0.27; extra == "windows-platform"

hypothesis>=6.56; extra == "windows-platform"

priority<2.0,>=1.1.0; extra == "windows-platform"

pyhamcrest>=2; extra == "windows-platform"

pyopenssl>=25.2.0; extra == "windows-platform"

pyserial>=3.0; extra == "windows-platform"

pywin32!=226; extra == "windows-platform"

pywin32!=226; platform_system == "Windows" and extra == "windows-platform"

service-identity>=18.1.0; extra == "windows-platform"

twisted-iocpsupport>=1.0.2; extra == "windows-platform"

Programming Language :: Python :: 3 :: Only


Summary: Traitlets Python configuration system

# Traitlets

[![Tests](https://github.com/ipython/traitlets/actions/workflows/tests.yml/badge.svg)](https://github.com/ipython/traitlets/actions/workflows/tests.yml)
[![Documentation Status](https://readthedocs.org/projects/traitlets/badge/?version=latest)](https://traitlets.readthedocs.io/en/latest/?badge=latest)
[![Tidelift](https://tidelift.com/subscription/pkg/pypi-traitlets)](https://tidelift.com/badges/package/pypi/traitlets)

|               |                                      |
| ------------- | ------------------------------------ |
| **home**      | https://github.com/ipython/traitlets |
| **pypi-repo** | https://pypi.org/project/traitlets/  |
| **docs**      | https://traitlets.readthedocs.io/    |
| **license**   | Modified BSD License                 |

Traitlets is a pure Python library enabling:

- the enforcement of strong typing for attributes of Python objects
  (typed attributes are called _"traits"_);
- dynamically calculated default values;
- automatic validation and coercion of trait attributes when attempting a
  change;
- registering for receiving notifications when trait values change;
- reading configuring values from files or from command line
  arguments - a distinct layer on top of traitlets, so you may use
  traitlets without the configuration machinery.

Its implementation relies on the [descriptor](https://docs.python.org/howto/descriptor.html)
pattern, and it is a lightweight pure-python alternative of the
[_traits_ library](https://docs.enthought.com/traits/).

Traitlets powers the configuration system of IPython and Jupyter
and the declarative API of IPython interactive widgets.

## Installation

For a local installation, make sure you have
[pip installed](https://pip.pypa.io/en/stable/installing/) and run:

```bash
pip install traitlets
```

For a **development installation**, clone this repository, change into the
`traitlets` root directory, and run pip:

```bash
git clone https://github.com/ipython/traitlets.git
cd traitlets

IPython Development Team <ipython-dev@python.org>

BSD 3-Clause License

        - Copyright (c) 2001-, IPython Development Team

        All rights reserved.

        Redistribution and use in source and binary forms, with or without
        modification, are permitted provided that the following conditions are met:

        1. Redistributions of source code must retain the above copyright notice, this
           list of conditions and the following disclaimer.

        2. Redistributions in binary form must reproduce the above copyright notice,
           this list of conditions and the following disclaimer in the documentation
           and/or other materials provided with the distribution.

        3. Neither the name of the copyright holder nor the names of its
           contributors may be used to endorse or promote products derived from
           this software without specific prior written permission.

        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

argcomplete>=3.0.3; python_version < "3.12" and extra == "test"

argcomplete>=3.5.2; python_version >= "3.12" and extra == "test"

mypy>=2.0; implementation_name != "pypy" and extra == "test"

pytest-mypy-testing; implementation_name != "pypy" and extra == "test"


Summary: A lil' TOML parser

[![Build Status](https://github.com/hukkin/tomli/actions/workflows/tests.yaml/badge.svg?branch=master)](https://github.com/hukkin/tomli/actions?query=workflow%3ATests+branch%3Amaster+event%3Apush)
[![codecov.io](https://codecov.io/gh/hukkin/tomli/branch/master/graph/badge.svg)](https://codecov.io/gh/hukkin/tomli)
[![PyPI version](https://img.shields.io/pypi/v/tomli)](https://pypi.org/project/tomli)

# Tomli

> A lil' TOML parser

**Table of Contents** *generated with [mdformat-toc](https://github.com/hukkin/mdformat-toc)*

- [Intro](#intro)
- [Installation](#installation)
- [Usage](#usage)
  - [Parse a TOML string](#parse-a-toml-string)
  - [Parse a TOML file](#parse-a-toml-file)
  - [Handle invalid TOML](#handle-invalid-toml)
  - [Construct `decimal.Decimal`s from TOML floats](#construct-decimaldecimals-from-toml-floats)
  - [Building a `tomli`/`tomllib` compatibility layer](#building-a-tomlitomllib-compatibility-layer)
- [FAQ](#faq)
  - [Why this parser?](#why-this-parser)
  - [Is comment preserving round-trip parsing supported?](#is-comment-preserving-round-trip-parsing-supported)
  - [Is there a `dumps`, `write` or `encode` function?](#is-there-a-dumps-write-or-encode-function)
  - [How do TOML types map into Python types?](#how-do-toml-types-map-into-python-types)
- [Performance](#performance)
  - [Mypyc generated wheel](#mypyc-generated-wheel)
  - [Pure Python](#pure-python)

## Intro

Tomli is a Python library for parsing [TOML](https://toml.io).
Version 2.4.0 and later are compatible with [TOML v1.1.0](https://toml.io/en/v1.1.0).
Older versions are [TOML v1.0.0](https://toml.io/en/v1.0.0) compatible.

A version of Tomli, the `tomllib` module,
was added to the standard library in Python 3.11
via [PEP 680](https://www.python.org/dev/peps/pep-0680/).
Tomli continues to provide a backport on PyPI for Python versions
where the standard library modul


Summary: Pretty-print tabular data

python-tabulate
===============

Pretty-print tabular data in Python, a library and a command-line
utility.

The main use cases of the library are:

-   printing small tables without hassle: just one function call,
    formatting is guided by the data itself
-   authoring tabular data for lightweight plain-text markup: multiple
    output formats suitable for further editing or transformation
-   readable presentation of mixed textual and numeric data: smart
    column alignment, configurable number formatting, alignment by a
    decimal point

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

To install the Python library and the command line utility, run:

```shell
pip install tabulate
```

The command line utility will be installed as `tabulate` to `bin` on
Linux (e.g. `/usr/bin`); or as `tabulate.exe` to `Scripts` in your
Python installation on Windows (e.g. `C:\Python39\Scripts\tabulate.exe`).

You may consider installing the library only for the current user:

```shell
pip install tabulate --user
```

In this case the command line utility will be installed to
`~/.local/bin/tabulate` on Linux and to
`%APPDATA%\Python\Scripts\tabulate.exe` on Windows.

To install just the library on Unix-like operating systems:

```shell
TABULATE_INSTALL=lib-only pip install tabulate
```

On Windows:

```shell
set TABULATE_INSTALL=lib-only
pip install tabulate
```

Build status
------------

[![python-tabulate](https://github.com/astanin/python-tabulate/actions/workflows/tabulate.yml/badge.svg)](https://github.com/astanin/python-tabulate/actions/workflows/tabulate.yml)

Library usage
-------------

The module provides just one function, `tabulate`, which takes a list of
lists or another tabular data type as the first argument, and outputs a
nicely formatted plain-text table:

```pycon
>>> from tabulate import tabulate

>>> table = [["Sun",696000,1989100000],["Earth",6371,5973.6],
...          ["Moon",1737,73.5],["Mars",3390,641.85]]

Topic :: Software Development :: Libraries


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"

Development Status :: 5 - Production/Stable

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


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"


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

# redis-py

The Python interface to the Redis key-value store.

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

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

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

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

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

## How do I Redis?

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

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

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

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

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

## Installation

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

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

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

``` bash
do

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

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

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

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

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


# Ruff

[![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)
[![image](https://img.shields.io/pypi/v/ruff.svg)](https://pypi.python.org/pypi/ruff)
[![image](https://img.shields.io/pypi/l/ruff.svg)](https://github.com/astral-sh/ruff/blob/main/LICENSE)
[![image](https://img.shields.io/pypi/pyversions/ruff.svg)](https://pypi.python.org/pypi/ruff)
[![Actions status](https://github.com/astral-sh/ruff/workflows/CI/badge.svg)](https://github.com/astral-sh/ruff/actions)
[![Discord](https://img.shields.io/badge/Discord-%235865F2.svg?logo=discord&logoColor=white)](https://discord.com/invite/astral-sh)

[**Docs**](https://docs.astral.sh/ruff/) | [**Playground**](https://play.ruff.rs/)

An extremely fast Python linter and code formatter, written in Rust.

  Linting the CPython codebase from scratch.

- ⚡ 10-100x faster than existing linters (like Flake8) and formatters (like Black)
- 🐍 Installable via `pip`
- 🛠 `pyproject.toml` support
- 🤝 Python 3.14 compatibility
- ⚖ Drop-in parity with [Flake8](https://docs.astral.sh/ruff/faq/#how-does-ruffs-linter-compare-to-flake8), [isort](https://docs.astral.sh/ruff/faq/#how-does-ruffs-import-sorting-compare-to-isort), and [Black](https://docs.astral.sh/ruff/faq/#how-does-ruffs-formatter-compare-to-black)
- 📦 Built-in caching, to avoid re-analyzing unchanged files
- 🔧 Fix support, for automatic error correction (e.g., automatically remove unused imports)
- 📏 Over [900 built-in rules](https://docs.astral.sh/ruff/rules/), with native re-implementations
    of popular Flake8 plugins, like flake8-bugbear
- ⌨ First-party [editor integrations](https://docs.astral.sh/ruff/editors) for [VS C

Topic :: Software Development :: Quality Assurance

automation, flake8, pycodestyle, pyflakes, pylint, clippy


Summary: Ray provides a simple, universal API for building distributed applications.

.. image:: https://github.com/ray-project/ray/raw/master/doc/source/images/ray_header_logo.png

.. image:: https://readthedocs.org/projects/ray/badge/?version=master
    :target: http://docs.ray.io/en/master/?badge=master

.. image:: https://img.shields.io/badge/Ray-Join%20Slack-blue
    :target: https://www.ray.io/join-slack

.. image:: https://img.shields.io/badge/Discuss-Ask%20Questions-blue
    :target: https://discuss.ray.io/

.. image:: https://img.shields.io/twitter/follow/raydistributed.svg?style=social&logo=twitter
    :target: https://x.com/raydistributed

.. image:: https://img.shields.io/badge/Get_started_for_free-3C8AE9?logo=data%3Aimage%2Fpng%3Bbase64%2CiVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8%2F9hAAAAAXNSR0IArs4c6QAAAERlWElmTU0AKgAAAAgAAYdpAAQAAAABAAAAGgAAAAAAA6ABAAMAAAABAAEAAKACAAQAAAABAAAAEKADAAQAAAABAAAAEAAAAAA0VXHyAAABKElEQVQ4Ea2TvWoCQRRGnWCVWChIIlikC9hpJdikSbGgaONbpAoY8gKBdAGfwkfwKQypLQ1sEGyMYhN1Pd%2B6A8PqwBZeOHt%2FvsvMnd3ZXBRFPQjBZ9K6OY8ZxF%2B0IYw9PW3qz8aY6lk92bZ%2BVqSI3oC9T7%2FyCVnrF1ngj93us%2B540sf5BrCDfw9b6jJ5lx%2FyjtGKBBXc3cnqx0INN4ImbI%2Bl%2BPnI8zWfFEr4chLLrWHCp9OO9j19Kbc91HX0zzzBO8EbLK2Iv4ZvNO3is3h6jb%2BCwO0iL8AaWqB7ILPTxq3kDypqvBuYuwswqo6wgYJbT8XxBPZ8KS1TepkFdC79TAHHce%2F7LbVioi3wEfTpmeKtPRGEeoldSP%2FOeoEftpP4BRbgXrYZefsAI%2BP9JU7ImyEAAAAASUVORK5CYII%3D
   :target: https://www.anyscale.com/ray-on-anyscale?utm_source=github&utm_medium=ray_readme&utm_campaign=get_started_badge

Ray is a unified framework for scaling AI and Python applications. Ray consists of a core distributed runtime and a set of AI libraries for simplifying ML compute:

.. image:: https://github.com/ray-project/ray/raw/master/doc/source/images/what-is-ray-padded.svg

..
  https://docs.google.com/drawings/d/1Pl8aCYOsZCo61cmp57c7Sja6HhIygGCvSZLi_AuBuqo/edit

Learn more about `Ray AI Libraries`_:

- `Data`_: Scalable Datasets for ML
- `Train`_: Distributed Training
- `Tune`_: Scalable Hyperparameter Tuning
- `RLlib`_: Scalable Reinforcement Learning
- `Serve`_: Scalable an

cupy-cuda12x; sys_platform != "darwin" and extra == "cgraph"

grpcio!=1.56.0; sys_platform == "darwin" and extra == "client"

py-spy>=0.2.0; python_version < "3.12" and extra == "default"

py-spy>=0.4.0; python_version >= "3.12" and extra == "default"

opentelemetry-sdk>=1.30.0; extra == "default"

opentelemetry-exporter-prometheus; extra == "default"

pydantic<3,>=2.5.0; python_version < "3.14" and extra == "default"

pydantic<3,>=2.13.0; python_version >= "3.14" and extra == "default"

prometheus_client>=0.7.1; extra == "default"

memray; sys_platform != "win32" and extra == "observability"

pydantic<3,>=2.13.0; python_version >= "3.14" and extra == "serve"

pydantic<3,>=2.5.0; python_version < "3.14" and extra == "serve"

py-spy>=0.4.0; python_version >= "3.12" and extra == "serve"

opentelemetry-exporter-prometheus; extra == "serve"

opentelemetry-sdk>=1.30.0; extra == "serve"

prometheus_client>=0.7.1; extra == "serve"

py-spy>=0.2.0; python_version < "3.12" and extra == "serve"

pydantic<3,>=2.5.0; python_version < "3.14" and extra == "tune"

pydantic<3,>=2.13.0; python_version >= "3.14" and extra == "tune"

cupy-cuda12x; sys_platform != "darwin" and extra == "adag"

pydantic<3,>=2.13.0; python_version >= "3.14" and extra == "serve-grpc"

pydantic<3,>=2.5.0; python_version < "3.14" and extra == "serve-grpc"

py-spy>=0.4.0; python_version >= "3.12" and extra == "serve-grpc"

opentelemetry-exporter-prometheus; extra == "serve-grpc"

uvicorn[standard]; extra == "serve-grpc"

opentelemetry-sdk>=1.30.0; extra == "serve-grpc"

prometheus_client>=0.7.1; extra == "serve-grpc"

opentelemetry-proto; extra == "serve-grpc"

py-spy>=0.2.0; python_version < "3.12" and extra == "serve-grpc"

pydantic<3,>=2.13.0; python_version >= "3.14" and extra == "serve-async-inference"

starlette>=1.0.1; extra == "serve-async-inference"

pydantic<3,>=2.5.0; python_version < "3.14" and extra == "serve-async-inference"

colorful; extra == "serve-async-inference"

py-spy>=0.4.0; python_version >= "3.12" and extra == "serve-async-inference"

opentelemetry-exporter-prometheus; extra == "serve-async-inference"

uvicorn[standard]; extra == "serve-async-inference"

requests; extra == "serve-async-inference"

smart_open; extra == "serve-async-inference"

opencensus; extra == "serve-async-inference"

watchfiles; extra == "serve-async-inference"

aiohttp>=3.13.3; extra == "serve-async-inference"

taskiq; extra == "serve-async-inference"

aiohttp_cors; extra == "serve-async-inference"

virtualenv!=20.21.1,>=20.0.24; extra == "serve-async-inference"

opentelemetry-sdk>=1.30.0; extra == "serve-async-inference"

grpcio>=1.42.0; extra == "serve-async-inference"

prometheus_client>=0.7.1; extra == "serve-async-inference"

opentelemetry-proto; extra == "serve-async-inference"

celery; extra == "serve-async-inference"

fastapi>=0.133.0; extra == "serve-async-inference"

py-spy>=0.2.0; python_version < "3.12" and extra == "serve-async-inference"

pydantic<3,>=2.5.0; python_version < "3.14" and extra == "rllib"

pydantic<3,>=2.13.0; python_version >= "3.14" and extra == "rllib"

pydantic<3,>=2.5.0; python_version < "3.14" and extra == "train"

pydantic<3,>=2.13.0; python_version >= "3.14" and extra == "train"

pydantic<3,>=2.13.0; python_version >= "3.14" and extra == "air"

pydantic<3,>=2.5.0; python_version < "3.14" and extra == "air"

py-spy>=0.4.0; python_version >= "3.12" and extra == "air"

opentelemetry-exporter-prometheus; extra == "air"

opentelemetry-sdk>=1.30.0; extra == "air"

prometheus_client>=0.7.1; extra == "air"

py-spy>=0.2.0; python_version < "3.12" and extra == "air"

pydantic<3,>=2.13.0; python_version >= "3.14" and extra == "all"

pydantic<3,>=2.5.0; python_version < "3.14" and extra == "all"

py-spy>=0.4.0; python_version >= "3.12" and extra == "all"

opentelemetry-exporter-prometheus; extra == "all"

cupy-cuda12x; sys_platform != "darwin" and extra == "all"

grpcio!=1.56.0; sys_platform == "darwin" and extra == "all"

memray; sys_platform != "win32" and extra == "all"

opentelemetry-sdk>=1.30.0; extra == "all"

prometheus_client>=0.7.1; extra == "all"

py-spy>=0.2.0; python_version < "3.12" and extra == "all"

pydantic<3,>=2.13.0; python_version >= "3.14" and extra == "all-cpp"

pydantic<3,>=2.5.0; python_version < "3.14" and extra == "all-cpp"

py-spy>=0.4.0; python_version >= "3.12" and extra == "all-cpp"

opentelemetry-exporter-prometheus; extra == "all-cpp"

cupy-cuda12x; sys_platform != "darwin" and extra == "all-cpp"

grpcio!=1.56.0; sys_platform == "darwin" and extra == "all-cpp"

memray; sys_platform != "win32" and extra == "all-cpp"

opentelemetry-sdk>=1.30.0; extra == "all-cpp"

prometheus_client>=0.7.1; extra == "all-cpp"

py-spy>=0.2.0; python_version < "3.12" and extra == "all-cpp"

pydantic<3,>=2.13.0; python_version >= "3.14" and extra == "llm"

pydantic<3,>=2.5.0; python_version < "3.14" and extra == "llm"

py-spy>=0.4.0; python_version >= "3.12" and extra == "llm"

opentelemetry-exporter-prometheus; extra == "llm"

async-timeout; python_version < "3.11" and extra == "llm"

opentelemetry-sdk>=1.30.0; extra == "llm"

prometheus_client>=0.7.1; extra == "llm"

py-spy>=0.2.0; python_version < "3.12" and extra == "llm"

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

ray distributed parallel machine-learning hyperparameter-tuningreinforcement-learning deep-learning serving python


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

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

.. contents::
   :local:

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

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

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

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

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

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

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

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

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

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

    pip install robotframework

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

Robot Framework requires Python 3.8 or newer and

Topic :: Software Development :: Testing :: Acceptance

Topic :: Software Development :: Testing :: BDD

robotframework automation testautomation rpa testing acceptancetesting atdd bdd


Summary: ROS package library

Library for retrieving information about ROS packages and stacks.

catkin-pkg
PyYAML
distro>=1.4.0; python_version >= "3.8"
pytest; extra == "test"

License :: OSI Approved :: BSD License
Programming Language :: Python


Summary: Pure-Python RSA implementation

# Python-RSA has been archived

Hi folks,

I'm Sybren, one of the original authors and the maintainer of this project.
Unfortunately I don't have the time and brain space left to properly maintain
Python-RSA. As you can see from the lack of activity on the open issues, and the
lack of commits, that has been the case for a while now.

As Python-RSA is included as a dependency in quite a few high-profile projects,
I don't feel comfortable handing over the project to someone else. It's just too
big of a risk.

Thanks for having used this little library for so long, and in so many projects.
I truely didn't expect that when I started working on it. Also big thanks to all
the people helping out and improving the project.

There are improvements that haven't made it into a new release. As I said, I
don't have the time and the brain space to really investigate and oversee the
security impact of all those changes. It's not a decision I've made lightly.

So that's it. If you want to keep the project alive, please fork it. Give it the
love it deserves, investigate those yet-unreleased improvements, and have a
project that's then already better than how I left this one.

Cheers,
Sybren

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

# Pure Python RSA implementation

[![PyPI](https://img.shields.io/pypi/v/rsa.svg)](https://pypi.org/project/rsa/)
[![Build Status](https://travis-ci.org/sybrenstuvel/python-rsa.svg?branch=master)](https://travis-ci.org/sybrenstuvel/python-rsa)
[![Coverage Status](https://coveralls.io/repos/github/sybrenstuvel/python-rsa/badge.svg?branch=master)](https://coveralls.io/github/sybrenstuvel/python-rsa?branch=master)
[![Code Climate](https://api.codeclimate.com/v1/badges/a99a88d28ad37a79dbf6/maintainability)](https://codeclimate.com/github/codeclimate/codeclimate/maintainability)

[Python-RSA](https://stuvel.eu/rsa) is a pure-Python RSA implementation. It supports
encryption and decryption, signing and verifying signatures, and key
generation according t

Intended Audience :: Information Technology

Programming Language :: Python :: Implementation :: PyPy


Summary: Retrying

# Retrying

Retrying is an Apache 2.0 licensed general-purpose retrying library, written in
Python, to simplify the task of adding retry behavior to just about anything.

The simplest use case is retrying a flaky function whenever an Exception occurs
until a value is returned.

```python
import random
from retrying import retry

@retry
def do_something_unreliable():
    if random.randint(0, 10) > 1:
        raise IOError("Broken sauce, everything is hosed!!!111one")
    else:
        return "Awesome sauce!"

print(do_something_unreliable())
```

## Features

- Generic Decorator API
- Specify stop condition (i.e. limit by number of attempts)
- Specify wait condition (i.e. exponential backoff sleeping between attempts)
- Customize retrying on Exceptions
- Customize retrying on expected returned result

## Examples

As you saw above, the default behavior is to retry forever without waiting.

```python
@retry
def never_give_up_never_surrender():
    print("Retry forever ignoring Exceptions, don't wait between retries")
```

Let's be a little less persistent and set some boundaries, such as the number of attempts before giving up.

```python
@retry(stop_max_attempt_number=7)
def stop_after_7_attempts():
    print("Stopping after 7 attempts")
```

We don't have all day, so let's set a boundary for how long we should be retrying stuff.

```python
@retry(stop_max_delay=10000)
def stop_after_10_s():
    print("Stopping after 10 seconds")
```

Most things don't like to be polled as fast as possible, so let's just wait 2 seconds between retries.

```python
@retry(wait_fixed=2000)
def wait_2_s():
    print("Wait 2 second between retries")
```

Some things perform best with a bit of randomness injected.

```python
@retry(wait_random_min=1000, wait_random_max=2000)
def wait_random_1_to_2_s():
    print("Randomly wait 1 to 2 seconds between retries")
```

Then again, it's hard to beat exponential backoff when retrying distributed services and other remote endpoints.

```python
@re

Alex Kuang, Anthony McClosky, Cyrus Durgin, Daniel Nephin, Dougal Matthews, Greg Roodt, Haïkel Guémar, Hugo Klepsch, J Derek Wilson, James Page, Jason Dunkelberger, Job Evers, Jonathan Herriott, Josh Marshall, Joshua Harlow, Justin Turner Arthur, Maxym Shalenyi, Monty Taylor, Pierre-Yves Chibon, Ray Holder, Rees Dooley, Saul Shanabrook, Simon Dollé, Simeon Visser, Thomas Goirand

decorator, decorators, retry, retrying, exception, exponential, backoff