puff-rs 0.1.2

Puff - Deep Stack Python Runtime and GraphQL library.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

import contextvars
import dataclasses
from typing import Any

from flask import Flask

import puff
import puff.postgres
import redis

SAMPLE = 1000

app = Flask(__name__)
r = redis.Redis(host="localhost")

puff_redis = puff.global_redis()


@app.route("/pg/")
def hello_world_pg():
    postgres_conn = puff.postgres.PostgresConnection()
    cursor = postgres_conn.cursor()
    cursor.execute("SELECT '[1,2,3]'::jsonb")
    results = cursor.fetchall()
    return str(results)


@app.route("/deep/")
def hello_world_puff():
    redis_set("blam", "ok").join()
    gets = []
    for _ in range(SAMPLE):
        gets.append(redis_get("blam"))
    return b"".join(puff.join_all(gets))


@app.route("/deeper/")
def hello_world_concat():
    redis_set("blam", "ok").join()
    return redis_get_many("blam", SAMPLE).join()


@puff.blocking
@app.route("/shallow/")
def hello_world():
    r.set("blam", "ok")
    gets = []
    for _ in range(SAMPLE):
        gets.append(r.get("blam"))
    return b"".join(gets)


from puff import wrap_async


def redis_get(q):
    return wrap_async(lambda rr: puff_redis.get(rr, q), join=False)


def redis_get_many(q, l):
    return wrap_async(
        lambda rr: puff.global_state().concat_redis_gets(rr, q, l), join=False
    )


def redis_set(k, v):
    return wrap_async(lambda rr: puff_redis.set(rr, k, v), join=False)


# def app(environ, start_response):
#     start_response("200 OK", [])
#     redis_set("blam", "ok")
#     gets = []
#     for _ in range(SAMPLE):
#         gets.append(redis_get("blam"))
#     return [b"".join(gets)]
#
#
# def do_work(q, return_result):
#     return_result(q)
#
#
# def redis_get(q):
#     return wrap_async(lambda rr: do_work(q, rr))
#
#
# def my_job():
#     r = redis_get("blam")
#     print(f"Got {r} from redis.")
#     r = redis_get("blam2")
#     print(f"Got {r} from redis again.")
#
#
# t = start_event_loop()
#
#
# def returner(r):
#     print(f"Got {r} as a value.")
#
#
# t.spawn(my_job, [], {}, returner)
# t.spawn(my_job, [], {}, returner)
# t.spawn(my_job, [], {}, returner)
# t.spawn(my_job, [], {}, returner)