semvec/pypi-packages huggingface dataset:
ECCArithmetic 1.0.0
Python Elliptic Curve Arithmetic Library.
Requires Python: >=3.0

# ECCArithmetic

## Installation
```
pip install ECCArithmetic
```

## Generate the Curve
```
from ECCArithmetic.ec import *

Curve = EC(0, 5, 2, 23981)

```

## PickGenerator
```python
from ECCArithmetic.ec import *

Curve = EC(0, 5, 2, 23981)
G = Curve.pickGenerator()

```

## PickPoint
```python
from ECCArithmetic.ec import *

Curve = EC(0, 5, 2, 23981)
P = Curve.pickPoint()
```

## isPointOnEC
Multiplication is realised with the double and add algorithm.
```python
from ECCArithmetic.ec import *

Curve = EC(0, 5, 2, 23981)
G = Curve.isPointOnEC([14967, 14215])
```

## Identity Element
```python
from ECCArithmetic.ec import *

O = ECPt.identity()
```

## Find All Points
```python
from ECCArithmetic.ec import *

Curve = EC(0, 5, 2, 23981)
all = Curve.enumerateAllPoints()

```

## Addition
```python
from ECCArithmetic.ec import *

Curve = EC(0, 5, 2, 23981)
P = Curve.pickPoint()
Q = Curve.pickPoint()

S = P + Q

```

## Subtraction
```python
from ECCArithmetic.ec import *

Curve = EC(0, 5, 2, 23981)
P = Curve.pickPoint()
Q = Curve.pickPoint()

S = P - Q
```

## Multiplication
```python
from ECCArithmetic.ec import *

Curve = EC(0, 5, 2, 23981)
P = Curve.pickPoint()
Q = Curve.pickPoint()

S = P * Q
```
redque 0.1.0
A distributed queue based on Redis.
Keywords: Redis,Queue

redque
======

A distributed queue based on Redis

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

.. code-block:: python

    pip install redque

Example
-------

.. code-block:: python

    import time
    import random
    import threading
    import redis
    import redque


    def productor(redis_conn):
        other_queue = redque.Queue(redis_conn, "__test", "bp__test")

        for _ in range(100):
            other_queue.push("e_{0}".format(random.randint(1, 100)))
            time.sleep(0.1)


    if __name__ == "__main__":
        pool = redis.ConnectionPool(
            host="127.0.0.1",
            port=6379,
            password="123456"
        )

        queue = redque.Queue(
            redis.Redis(connection_pool=pool),
            "__test",
            "bp__test"
        )
        queue.clear(True)

        # non-blocking
        for _ in range(100):
            queue.push(random.randint(1, 100))

        queue.process(lambda x: (print(x), True), False)

        # blocking
        t = threading.Thread(target=productor,
                            args=(redis.Redis(connection_pool=pool),))
        t.start()

        queue.process(lambda x: (print(x), True), timeout=3)

        t.join()
gerardo 0.1.1
Simple decorator for multiprocessing and psql insertion
Keywords: psql multiprocessing

# gerardo

[![PyPI version](https://badge.fury.io/py/gerardo.svg)](https://badge.fury.io/py/gerardo)

**gerardo** provides decorators to easily compute in parallel and store the
results in a PostgreSQL database.

## Usage

See `examples/example.py` for more details.

```python
from gerardo import psql_mp_insert, psql_handler

# Set a PostgreSQL handler
pghost = os.environ["PGHOST"]
DSN = {
    "host": pghost,
    "port": "",
    "user": "",
    "password": "",
    "dbname": "example_db",
}
PSQL_TABLE = "test_table"
COLUMNS = [('x', 'INT'), ('y', 'INT')]

PH = psql_handler(DSN, PSQL_TABLE, COLUMNS)

# Define a single-variable function.
@psql_mp_insert(PH)
def f(x):
    return (x[0]+x[1], x[0]*x[1])

# Compute by forming a list of arguments
list_args = [(x, y) for x in range(5) for y in range(10)]
f(list_args)
```

## Installation

```
pip install gerardo --user
```


## Homepage

* https://github.com/kevinywlui/gerardo