which seems to be part of a disappointing trend where people are abandoning sphinx or rST for worse alternatives e.g. pip switchiing to markdown with a horrible hack to keep using directives or people switching to mkdocs which has nowhere near the nice functionality of sphinx
i used the guest mode
import asyncio import trio async def trio_run_with_asyncio(trio_fn, *args): asyncio_loop = asyncio.get_running_loop() def run_sync_soon_threadsafe(fn): asyncio_loop.call_soon_threadsafe(fn) done_fut = asyncio.Future() def done_callback(trio_main_outcome): done_fut.set_result(trio_main_outcome) trio.lowlevel.start_guest_run( trio_fn, *args, run_sync_soon_threadsafe=run_sync_soon_threadsafe, done_callback=done_callback, host_uses_signal_set_wakeup_fd=True ) trio_main_outcome = await done_fut return trio_main_outcome.unwrap()
async def trio_main(tasks):
results = {}
async def grabber(s, upstream_job, upstream_job_build, build_tag):
r = await s.get(
(f"{airflow_service.base_url}/api/v1"
f"/dags/{upstream_job}"
f"/dagRuns/{upstream_job_build}"
f"/taskInstances/{build_tag}"))
r.raise_for_status()
t = r.json()
results[build_tag] = t['state']
async with airflow_service.httpx_client() as session:
async with trio.open_nursery() as n:
for task in tasks:
n.start_soon(
grabber,
session,
task['upstream_job'],
task['upstream_job_build'],
task['build_tag']
)
return resultsfrom fastapi import APIRouter
from app.services.search import ElasticService
router = APIRouter()
@router.get('/api/results/{pipeline_id}/{job_id}')
async def results_for_job(pipeline_id: str, job_id: str):
# query async elasticsearch for tasks
...
tasks_states = await trio_run_with_asyncio(trio_main, tasks)
for task in tasks:
task['job_status'] = tasks_states[task['build_tag']]
return tasks
I'm not clear from an error message if it's a pattern, a trio thing, or a Python built-in that I'm not aware of.
new in 3.10
it's been used elsewhere (https://github.com/python-trio/async_generator/blob/9f0e08c762dc2b9e18a38e8dd714790a319ed836/async_generator/_util.py#L6 for example) before it made it into 3.10
an underrated benefit of the trio release is that the stable version of the "awesome trio" page in the docs is current now
@tomchristie technically you need it for regular generators too
6 replies
Eg on pypy
contextlib.closing or yield from
@graingert:matrix.org
trio-asyncio is compatible with some asyncio setups but not all. anyio is fully compatible with all asyncio setups and trio
This almost sounds like you're saying that anyio can do the job of trio-asyncio. That's not the case, right? If I have a trio app where I have one asyncio library I need to use, I still need trio-asyncio to handle those calls, right?
1 reply
@mfleader Repeating this from earlier thread because some interfaces seem to have trouble notifying people of threads.
how does one change the dependency of a dependency (starlette used by fastapi)?
With Poetry, you can add an optional dep to your app to constrain the version of something pulled in by another dep (of course, the constraints have to have some overlap to be solvable).
unfortunately fastapi is exact in its starlette requirement: https://github.com/tiangolo/fastapi/blob/master/pyproject.toml#L35
requires = ["starlette ==0.14.2",
A PR to update the pin might be accepted though
wow, seriously loving the new
async with (): (with tuple) syntax in 3.9
1 reply
so many indentation levels removed 😂
yeah basically multiple expressions between parentheses
i guess it was undocumented but in 3.9?
it's so weird i thought i was losing it at first bc they didn't doc it in 3.9 release notes
but it definitely works
@uSpike: so yes that's it
huh i wonder if the
match works in 3.9 😂
In [17]: import time
...: import httpx
...: import trio
...:
...: async def get(client, url, index, results):
...: response = await client.get(url)
...: results[index] = response.json()
...:
...: async def go():
...: results = {}
...: async with httpx.AsyncClient() as client, trio.open_nursery() as nursery:
...: for i in range(40):
...: nursery.start_soon(get, client, f"https://jsonplaceholder.typicode.com/todos/{i}", i, results)
...: #print(results)
...:
...: start = time.perf_counter()
...: await go()
...: stop = time.perf_counter()
...: print(f"Elapsed time: {stop-start}")
Elapsed time: 0.5561655089999249
@goodboy:matrix.org ^
2015 Macbook, Wifi, blah blah
This is doing my head in.
I've got a perfectly working web socket streamer using Trio.
It's really simple.
But I modify it slightly and it now fails.
import trio
from trio_websocket import open_websocket_url
class WSProxy:
KEEPALIVE_INTERVAL_S = 3
def __init__(self, url_remote):
self.url_remote = url_remote
self.socket_to_remote = None
async def run(self):
async with trio.open_nursery() as nursery:
async def task_socket_to_remote():
async with open_websocket_url(self.url_remote) as socket_to_remote:
print(f'{self.url_remote} connected')
self.socket_to_remote = socket_to_remote
async def keepalive():
while True:
print('sending ping')
await socket_to_remote.ping()
print('Not hit')
await trio.sleep(WSProxy.KEEPALIVE_INTERVAL_S)
nursery.start_soon(keepalive)
print('Hits1')
nursery.start_soon(task_socket_to_remote)
print('Hits2')
while True:
await trio.sleep(1)
ws = WSProxy('wss://ws.hotbit.io')
trio.run(ws.run)This never reaches the next line after sending the ping.
All I've done is switched the nesting of the nursery and the socket connection.
Looks like my message is now locked in so I can't edit it.
Here's a stripped down version:
Here's a stripped down version:
import trio
from trio_websocket import open_websocket_url
class WSProxy:
KEEPALIVE_INTERVAL_S = 3
async def run(self):
async with open_websocket_url('wss://ws.hotbit.io') as socket_to_remote:
print('connected')
async with trio.open_nursery() as nursery:
async def keepalive():
while True:
print('sending ping')
await socket_to_remote.ping()
print('Not hit')
await trio.sleep(WSProxy.KEEPALIVE_INTERVAL_S)
nursery.start_soon(keepalive)
print('Why not hits???')
ws = WSProxy()
trio.run(ws.run)
The output is just
sending ping
await my_ws.ping() send a PING frame, and then blocks until it receives a PONG frame from the other side
and in theory websocket servers should always send a PONG frame after getting a PING frame, but, theory and practice are not always the same...