examples/debugging/asyncio_bp.py

@@ -77,9 +77,7 @@ async def main(
 
 ) -> None:
 
-    async with tractor.open_nursery(
-        # debug_mode=True,
-    ) as n:
+    async with tractor.open_nursery() as n:
 
         p = await n.start_actor(
             'aio_daemon',

tests/test_infected_asyncio.py

@@ -601,8 +601,7 @@ def test_echoserver_detailed_mechanics(
                             pass
                         else:
                             pytest.fail(
-                                'stream not stopped after sentinel ?!'
-                            )
+                                "stream wasn't stopped after sentinel?!")
 
             # TODO: the case where this blocks and
             # is cancelled by kbi or out of task cancellation
@@ -614,37 +613,3 @@ def test_echoserver_detailed_mechanics(
 
     else:
         trio.run(main)
-
-
-# TODO: debug_mode tests once we get support for `asyncio`!
-#
-# -[ ] need tests to wrap both scripts:
-#   - [ ] infected_asyncio_echo_server.py
-#   - [ ] debugging/asyncio_bp.py
-#  -[ ] consider moving ^ (some of) these ^ to `test_debugger`?
-#
-# -[ ] missing impl outstanding includes:
-#  - [x] for sync pauses we need to ensure we open yet another
-#    `greenback` portal in the asyncio task
-#    => completed using `.bestow_portal(task)` inside
-#     `.to_asyncio._run_asyncio_task()` right?
-#   -[ ] translation func to get from `asyncio` task calling to 
-#     `._debug.wait_for_parent_stdin_hijack()` which does root
-#     call to do TTY locking.
-#
-def test_sync_breakpoint():
-    '''
-    Verify we can do sync-func/code breakpointing using the
-    `breakpoint()` builtin inside infected mode actors.
-
-    '''
-    pytest.xfail('This support is not implemented yet!')
-
-
-def test_debug_mode_crash_handling():
-    '''
-    Verify mult-actor crash handling works with a combo of infected-`asyncio`-mode
-    and normal `trio` actors despite nested process trees.
-
-    '''
-    pytest.xfail('This support is not implemented yet!')

tractor/_context.py

@@ -351,7 +351,7 @@ class Context:
     by the runtime in 2 ways:
      - by entering ``Portal.open_context()`` which is the primary
        public API for any "caller" task or,
-     - by the RPC machinery's `._rpc._invoke()` as a `ctx` arg
+     - by the RPC machinery's `._runtime._invoke()` as a `ctx` arg
        to a remotely scheduled "callee" function.
 
     AND is always constructed using the below ``mk_context()``.
@@ -361,10 +361,10 @@ class Context:
     `trio.Task`s. Contexts are allocated on each side of any task
     RPC-linked msg dialog, i.e. for every request to a remote
     actor from a `Portal`. On the "callee" side a context is
-    always allocated inside ``._rpc._invoke()``.
+    always allocated inside ``._runtime._invoke()``.
 
-    TODO: more detailed writeup on cancellation, error and
-    streaming semantics..
+    # TODO: more detailed writeup on cancellation, error and
+    # streaming semantics..
 
     A context can be cancelled and (possibly eventually restarted) from
     either side of the underlying IPC channel, it can also open task
@@ -1206,9 +1206,7 @@ class Context:
                     # await pause()
                     log.warning(
                         'Stream was terminated by EoC\n\n'
-                        # NOTE: won't show the error <Type> but
-                        # does show txt followed by IPC msg.
-                        f'{str(eoc)}\n'
+                        f'{repr(eoc)}\n'
                     )
 
             finally:
@@ -1305,7 +1303,7 @@ class Context:
             # `._cancel_called == True`.
             not raise_overrun_from_self
             and isinstance(remote_error, RemoteActorError)
-            and remote_error.msgdata['boxed_type_str'] == 'StreamOverrun'
+            and remote_error.msgdata['type_str'] == 'StreamOverrun'
             and tuple(remote_error.msgdata['sender']) == our_uid
         ):
             # NOTE: we set the local scope error to any "self
@@ -1882,19 +1880,6 @@ class Context:
             return False
 
 
-# TODO: exception tb masking by using a manual
-# `.__aexit__()`/.__aenter__()` pair on a type?
-# => currently this is one of the few places we can't easily
-# mask errors - on the exit side of a `Portal.open_context()`..
-# there's # => currently this is one of the few places we can't
-# there's 2 ways to approach it:
-# - manually write an @acm type as per above
-# - use `contextlib.AsyncContextDecorator` to override the default
-#   impl to suppress traceback frames:
-#  * https://docs.python.org/3/library/contextlib.html#contextlib.AsyncContextDecorator
-#  * https://docs.python.org/3/library/contextlib.html#contextlib.ContextDecorator
-# - also we could just override directly the underlying
-#   `contextlib._AsyncGeneratorContextManager`?
 @acm
 async def open_context_from_portal(
     portal: Portal,

tractor/_supervise.py

@@ -583,7 +583,7 @@ async def open_nursery(
     finally:
         msg: str = (
             'Actor-nursery exited\n'
-            f'|_{an}\n'
+            f'|_{an}\n\n'
         )
 
         # shutdown runtime if it was started

tractor/devx/_debug.py

@@ -187,18 +187,13 @@ class Lock:
         `trio.to_thread.run_sync()`.
 
         '''
-        is_trio_main = (
+        return (
             # TODO: since this is private, @oremanj says
             # we should just copy the impl for now..
             trio._util.is_main_thread()
             and
-            (async_lib := sniffio.current_async_library()) == 'trio'
+            sniffio.current_async_library() == 'trio'
         )
-        if not is_trio_main:
-            log.warning(
-                f'Current async-lib detected by `sniffio`: {async_lib}\n'
-            )
-        return is_trio_main
         # XXX apparently unreliable..see ^
         # (
         #     threading.current_thread()
@@ -1119,14 +1114,6 @@ def pause_from_sync(
             '- `async with tractor.open_root_actor()`\n'
         )
 
-    # NOTE: once supported, remove this AND the one
-    # inside `._pause()`!
-    if actor.is_infected_aio():
-        raise RuntimeError(
-            '`tractor.pause[_from_sync]()` not yet supported '
-            'for infected `asyncio` mode!'
-        )
-
     # raises on not-found by default
     greenback: ModuleType = maybe_import_greenback()
     mdb: MultiActorPdb = mk_mpdb()

tractor/to_asyncio.py

@@ -33,14 +33,10 @@ from typing import (
 import trio
 from outcome import Error
 
-from tractor.log import get_logger
-from tractor._state import (
-    current_actor,
-    debug_mode,
-)
-from tractor.devx import _debug
-from tractor._exceptions import AsyncioCancelled
-from tractor.trionics._broadcast import (
+from .log import get_logger
+from ._state import current_actor
+from ._exceptions import AsyncioCancelled
+from .trionics._broadcast import (
     broadcast_receiver,
     BroadcastReceiver,
 )
@@ -162,9 +158,7 @@ def _run_asyncio_task(
     '''
     __tracebackhide__ = True
     if not current_actor().is_infected_aio():
-        raise RuntimeError(
-            "`infect_asyncio` mode is not enabled!?"
-        )
+        raise RuntimeError("`infect_asyncio` mode is not enabled!?")
 
     # ITC (inter task comms), these channel/queue names are mostly from
     # ``asyncio``'s perspective.
@@ -259,7 +253,7 @@ def _run_asyncio_task(
     if not inspect.isawaitable(coro):
         raise TypeError(f"No support for invoking {coro}")
 
-    task: asyncio.Task = asyncio.create_task(
+    task = asyncio.create_task(
         wait_on_coro_final_result(
             to_trio,
             coro,
@@ -268,18 +262,6 @@ def _run_asyncio_task(
     )
     chan._aio_task = task
 
-    # XXX TODO XXX get this actually workin.. XD
-    # maybe setup `greenback` for `asyncio`-side task REPLing
-    if (
-        debug_mode()
-        and
-        (greenback := _debug.maybe_import_greenback(
-            force_reload=True,
-            raise_not_found=False,
-        ))
-    ):
-        greenback.bestow_portal(task)
-
     def cancel_trio(task: asyncio.Task) -> None:
         '''
         Cancel the calling ``trio`` task on error.
@@ -549,16 +531,6 @@ def run_as_asyncio_guest(
         loop = asyncio.get_running_loop()
         trio_done_fut = asyncio.Future()
 
-        if debug_mode():
-            # XXX make it obvi we know this isn't supported yet!
-            log.error(
-                'Attempting to enter unsupported `greenback` init '
-                'from `asyncio` task..'
-            )
-            await _debug.maybe_init_greenback(
-                force_reload=True,
-            )
-
         def trio_done_callback(main_outcome):
 
             if isinstance(main_outcome, Error):