reapxdev/pypi-scraper huggingface dataset:
bottle 0.13.4 — Fast and simple WSGI-framework for small web-applications.
Author: Marcel Hellkamp
License: MIT
pyrsistent 0.20.0 — Persistent/Functional/Immutable data structures
Author: Tobias Gustafsson
License: MIT 
Requires Python: >=3.8

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


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

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

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

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

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

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

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

Examples
--------
.. _Sequence: collections_
ecdsa 0.19.2 — ECDSA cryptographic signature library (pure python)
Author: Brian Warner
License: MIT 
Requires Python: !=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.6
Dependencies: six>=1.9.0, gmpy; extra == "gmpy", gmpy2; extra == "gmpy2"

# Pure-Python ECDSA and ECDH

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


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

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

## Features

This library provides key generation, signing, verifyi
docopt 0.6.2 — Pythonic argument parser, that will make you smile
Author: Vladimir Keleshev
License: MIT 
Keywords: option arguments parsing optparse argparse getopt

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

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

    New in version 0.6.1:

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

    New in version 0.6.0:

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

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

    Breaking changes:

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

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

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

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

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

.. code:: python

    """Naval Fate.

    Usage:
      naval_fate.py ship new <name>...
      naval_fate.py ship <name> move <x> <y> [--spe
Spark 0.4.1 — An easy to use actor model framework in Python
Author: Wensheng Wang
License: MIT 
Keywords: actor, concurrency, distributed, message-passing
Requires Python: >=3.13
Dependencies: black>=23.0.0; extra == "dev", cbor2<6,>=5.9; extra == "cbor2", isort>=5.12.0; extra == "dev", mypy>=1.0.0; extra == "dev", pytest>=7.0.0; extra == "test", pytest-asyncio>=0.21.0; extra == "test", pytest-cov>=4.0.0; extra == "test", ruff>=0.1.0; extra == "dev", websockets<17,>=16; extra == "websocket"

# Spark

Spark is an async-first actor framework for Python. The core API is small:
start a `Syndicate`, create actors, and send messages with `tell(message,
target)` or `ask(message, target)`.

Workflow routing lives in the explicit `spark.workflow` package. Distributed
features such as TCP routes, WebSocket routes, relay traversal, federation, and
persistence are opt-in.

## Install

```bash
pip install spark
pip install "spark[cbor2]"                 # structured remote payloads
pip install "spark[websocket,cbor2]"       # websocket and NAT relay examples
```

For local development:

```bash
uv venv -p 3.13
uv pip install -e ".[dev,test,websocket,cbor2]"
uv run pytest
```

## Quick Start

```python
from spark import Actor, Syndicate
from spark.core.message import Message


class Echo(Actor):
    async def process(self, message: Message) -> str:
        return f"echo:{message.content}"


async with Syndicate("app") as system:
    echo = await system.create_actor(Echo)
    print(await system.ask("hello", echo, timeout=1.0))
```

`tell(message, target)` is fire-and-forget. `ask(message, target)` waits for
the first reply or raises `ActorTimeout`.

```python
await system.tell("event", echo)
reply = await system.ask("request", echo, timeout=5.0)
```

Inside an actor, omitting `target` sends to the owning syndicate inbox today;
that shape is reserved for future broadcast/parent behavior.

## Core Capabilities

- Actor lifecycle through explicit `Syndicate` instances.
- Parent/child actors, monitoring, linking, and restart/resume/escalate
  supervision.
- Bounded mailboxes, TTL/deadline delivery, dead letters, late replies, runtime
  events, and diagnostics snapshots.
- Stateless thread/process execution with `ActorSpec`.
- `Troupe` actor pools for parallel local work.
- Durable actors and durable timers through `SQLiteJournal`.
- TCP remote routes with shared-secret HMAC handshake and frame integrity.
- WebSocket direct routes and authenticated WebSocket relay registra