Log warning instead of exception on pubsub cancelled

Stop exporting `_ringbuf` on `tractor.ipc`
Use absolute imports on `_ringbuf` module
Add more comments and acm helpers for ringbuf allocation functions
Create generic FD sharing actor module in `tractor.linux._fdshare`
Include original allocator actor name as `owner` in RBToken
Auto share FDs of allocated ringbufs
On `attach_ringbuf_*` functions request fds from owner
Adapt all ringbuf tests to new system

.github/workflows/ci.yml

@@ -15,19 +15,18 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v2
 
-      - name: Install the latest version of uv
+      - name: Setup python
-        uses: astral-sh/setup-uv@v5
+        uses: actions/setup-python@v2
+        with:
+          python-version: '3.11'
 
-      - name: Setup env
+      - name: Install dependencies
-        run: uv venv .venv --python=3.11
+        run: pip install -U . --upgrade-strategy eager -r requirements-test.txt
-
-      - name: Install
-        run: uv sync --group=dev
 
       - name: Run MyPy check
-        run: uv run mypy tractor/ --ignore-missing-imports --show-traceback
+        run: mypy tractor/ --ignore-missing-imports --show-traceback
 
   # test that we can generate a software distribution and install it
   # thus avoid missing file issues after packaging.
@@ -37,19 +36,18 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v2
 
-      - name: Install the latest version of uv
+      - name: Setup python
-        uses: astral-sh/setup-uv@v5
+        uses: actions/setup-python@v2
-
+        with:
-      - name: Setup env
+          python-version: '3.11'
-        run: uv venv .venv --python=3.11
 
       - name: Build sdist
-        run: uv build --sdist
+        run: python setup.py sdist --formats=zip
 
       - name: Install sdist from .zips
-        run: uv run pip install dist/*.tar.gz
+        run: python -m pip install dist/*.zip
 
 
   testing-linux:
@@ -69,23 +67,23 @@ jobs:
         ]
 
     steps:
+
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v2
 
-      - name: Install the latest version of uv
+      - name: Setup python
-        uses: astral-sh/setup-uv@v5
+        uses: actions/setup-python@v2
-
+        with:
-      - name: Setup env
+          python-version: '${{ matrix.python }}'
-        run: uv venv .venv --python=3.11
 
       - name: Install dependencies
-        run: uv sync --all-groups
+        run: pip install -U . -r requirements-test.txt -r requirements-docs.txt --upgrade-strategy eager
 
       - name: List dependencies
-        run: uv pip list
+        run: pip list
 
       - name: Run tests
-        run: uv run pytest tests/ --ignore=tests/devx --spawn-backend=${{ matrix.spawn_backend }} -rsx
+        run: pytest tests/ --spawn-backend=${{ matrix.spawn_backend }} -rsx
 
   # We skip 3.10 on windows for now due to not having any collabs to
   # debug the CI failures. Anyone wanting to hack and solve them is very

default.nix

@@ -10,5 +10,9 @@ pkgs.mkShell {
   inherit nativeBuildInputs;
 
   LD_LIBRARY_PATH = pkgs.lib.makeLibraryPath nativeBuildInputs;
-  TMPDIR = "/tmp";
+
+  shellHook = ''
+    set -e
+    uv venv .venv --python=3.11
+  '';
 }

examples/advanced_faults/ipc_failure_during_stream.py

@@ -120,7 +120,6 @@ async def main(
     break_parent_ipc_after: int|bool = False,
     break_child_ipc_after: int|bool = False,
     pre_close: bool = False,
-    tpt_proto: str = 'tcp',
 
 ) -> None:
 
@@ -132,7 +131,6 @@ async def main(
             # a hang since it never engages due to broken IPC
             debug_mode=debug_mode,
             loglevel=loglevel,
-            enable_transports=[tpt_proto],
 
         ) as an,
     ):
@@ -147,8 +145,7 @@ async def main(
             _testing.expect_ctxc(
                 yay=(
                     break_parent_ipc_after
-                    or
+                    or break_child_ipc_after
-                    break_child_ipc_after
                 ),
                 # TODO: we CAN'T remove this right?
                 # since we need the ctxc to bubble up from either

examples/service_discovery.py

@@ -9,7 +9,7 @@ async def main(service_name):
     async with tractor.open_nursery() as an:
         await an.start_actor(service_name)
 
-        async with tractor.get_registry() as portal:
+        async with tractor.get_registry('127.0.0.1', 1616) as portal:
             print(f"Arbiter is listening on {portal.channel}")
 
         async with tractor.wait_for_actor(service_name) as sockaddr:

pyproject.toml

@@ -46,7 +46,6 @@ dependencies = [
   # typed IPC msging
   "msgspec>=0.19.0",
   "cffi>=1.17.1",
-  "bidict>=0.23.1",
 ]
 
 # ------ project ------
@@ -64,10 +63,7 @@ dev = [
   "pyperclip>=1.9.0",
   "prompt-toolkit>=3.0.50",
   "xonsh>=0.19.2",
-  "numpy>=2.2.4", # used for fast test sample gen
+  "numpy>=2.2.4",  # used for fast test sample gen
-  "mypy>=1.15.0",
-  "psutil>=7.0.0",
-  "trio-typing>=0.10.0",
 ]
 # TODO, add these with sane versions; were originally in
 # `requirements-docs.txt`..

tests/conftest.py

@@ -1,8 +1,6 @@
 """
-Top level of the testing suites!
+``tractor`` testing!!
-
 """
-from __future__ import annotations
 import sys
 import subprocess
 import os
@@ -32,11 +30,7 @@ else:
     _KILL_SIGNAL = signal.SIGKILL
     _INT_SIGNAL = signal.SIGINT
     _INT_RETURN_CODE = 1 if sys.version_info < (3, 8) else -signal.SIGINT.value
-    _PROC_SPAWN_WAIT = (
+    _PROC_SPAWN_WAIT = 0.6 if sys.version_info < (3, 7) else 0.4
-        0.6
-        if sys.version_info < (3, 7)
-        else 0.4
-    )
 
 
 no_windows = pytest.mark.skipif(
@@ -45,9 +39,7 @@ no_windows = pytest.mark.skipif(
 )
 
 
-def pytest_addoption(
+def pytest_addoption(parser):
-    parser: pytest.Parser,
-):
     parser.addoption(
         "--ll",
         action="store",
@@ -64,8 +56,7 @@ def pytest_addoption(
     )
 
     parser.addoption(
-        "--tpdb",
+        "--tpdb", "--debug-mode",
-        "--debug-mode",
         action="store_true",
         dest='tractor_debug_mode',
         # default=False,
@@ -76,17 +67,6 @@ def pytest_addoption(
         ),
     )
 
-    # provide which IPC transport protocols opting-in test suites
-    # should accumulatively run against.
-    parser.addoption(
-        "--tpt-proto",
-        nargs='+',  # accumulate-multiple-args
-        action="store",
-        dest='tpt_protos',
-        default=['tcp'],
-        help="Transport protocol to use under the `tractor.ipc.Channel`",
-    )
-
 
 def pytest_configure(config):
     backend = config.option.spawn_backend
@@ -94,7 +74,7 @@ def pytest_configure(config):
 
 
 @pytest.fixture(scope='session')
-def debug_mode(request) -> bool:
+def debug_mode(request):
     debug_mode: bool = request.config.option.tractor_debug_mode
     # if debug_mode:
     #     breakpoint()
@@ -115,43 +95,11 @@ def spawn_backend(request) -> str:
     return request.config.option.spawn_backend
 
 
-@pytest.fixture(scope='session')
+# @pytest.fixture(scope='function', autouse=True)
-def tpt_protos(request) -> list[str]:
+# def debug_enabled(request) -> str:
-
+#     from tractor import _state
-    # allow quoting on CLI
+#     if _state._runtime_vars['_debug_mode']:
-    proto_keys: list[str] = [
+#         breakpoint()
-        proto_key.replace('"', '').replace("'", "")
-        for proto_key in request.config.option.tpt_protos
-    ]
-
-    # ?TODO, eventually support multiple protos per test-sesh?
-    if len(proto_keys) > 1:
-        pytest.fail(
-            'We only support one `--tpt-proto <key>` atm!\n'
-        )
-
-    # XXX ensure we support the protocol by name via lookup!
-    for proto_key in proto_keys:
-        addr_type = tractor._addr._address_types[proto_key]
-        assert addr_type.proto_key == proto_key
-
-    yield proto_keys
-
-
-@pytest.fixture(
-    scope='session',
-    autouse=True,
-)
-def tpt_proto(
-    tpt_protos: list[str],
-) -> str:
-    proto_key: str = tpt_protos[0]
-    from tractor import _state
-    if _state._def_tpt_proto != proto_key:
-        _state._def_tpt_proto = proto_key
-    # breakpoint()
-    yield proto_key
-
 
 _ci_env: bool = os.environ.get('CI', False)
 
@@ -159,7 +107,7 @@ _ci_env: bool = os.environ.get('CI', False)
 @pytest.fixture(scope='session')
 def ci_env() -> bool:
     '''
-    Detect CI environment.
+    Detect CI envoirment.
 
     '''
     return _ci_env
@@ -167,45 +115,30 @@ def ci_env() -> bool:
 
 # TODO: also move this to `._testing` for now?
 # -[ ] possibly generalize and re-use for multi-tree spawning
-#    along with the new stuff for multi-addrs?
+#    along with the new stuff for multi-addrs in distribute_dis
+#    branch?
 #
-# choose random port at import time
+# choose randomly at import time
-_rando_port: str = random.randint(1000, 9999)
+_reg_addr: tuple[str, int] = (
+    '127.0.0.1',
+    random.randint(1000, 9999),
+)
 
 
 @pytest.fixture(scope='session')
-def reg_addr(
+def reg_addr() -> tuple[str, int]:
-    tpt_proto: str,
-) -> tuple[str, int|str]:
 
     # globally override the runtime to the per-test-session-dynamic
     # addr so that all tests never conflict with any other actor
     # tree using the default.
-    from tractor import (
+    from tractor import _root
-        _addr,
+    _root._default_lo_addrs = [_reg_addr]
-    )
-    addr_type = _addr._address_types[tpt_proto]
-    def_reg_addr: tuple[str, int] = _addr._default_lo_addrs[tpt_proto]
 
-    testrun_reg_addr: tuple[str, int]
+    return _reg_addr
-    match tpt_proto:
-        case 'tcp':
-            testrun_reg_addr = (
-                addr_type.def_bindspace,
-                _rando_port,
-            )
-
-        # NOTE, file-name uniqueness (no-collisions) will be based on
-        # the runtime-directory and root (pytest-proc's) pid.
-        case 'uds':
-            testrun_reg_addr = addr_type.get_random().unwrap()
-
-    assert def_reg_addr != testrun_reg_addr
-    return testrun_reg_addr
 
 
 def pytest_generate_tests(metafunc):
-    spawn_backend: str = metafunc.config.option.spawn_backend
+    spawn_backend = metafunc.config.option.spawn_backend
 
     if not spawn_backend:
         # XXX some weird windows bug with `pytest`?
@@ -218,53 +151,45 @@ def pytest_generate_tests(metafunc):
         'trio',
     )
 
-    # NOTE: used-to-be-used-to dyanmically parametrize tests for when
+    # NOTE: used to be used to dyanmically parametrize tests for when
     # you just passed --spawn-backend=`mp` on the cli, but now we expect
     # that cli input to be manually specified, BUT, maybe we'll do
     # something like this again in the future?
     if 'start_method' in metafunc.fixturenames:
-        metafunc.parametrize(
+        metafunc.parametrize("start_method", [spawn_backend], scope='module')
-            "start_method",
-            [spawn_backend],
-            scope='module',
-        )
-
-    # TODO, parametrize any `tpt_proto: str` declaring tests!
-    # proto_tpts: list[str] = metafunc.config.option.proto_tpts
-    # if 'tpt_proto' in metafunc.fixturenames:
-    #     metafunc.parametrize(
-    #         'tpt_proto',
-    #         proto_tpts,  # TODO, double check this list usage!
-    #         scope='module',
-    #     )
 
 
-def sig_prog(
+# TODO: a way to let test scripts (like from `examples/`)
-    proc: subprocess.Popen,
+# guarantee they won't registry addr collide!
-    sig: int,
+# @pytest.fixture
-    canc_timeout: float = 0.1,
+# def open_test_runtime(
-) -> int:
+#     reg_addr: tuple,
+# ) -> AsyncContextManager:
+#     return partial(
+#         tractor.open_nursery,
+#         registry_addrs=[reg_addr],
+#     )
+
+
+def sig_prog(proc, sig):
     "Kill the actor-process with ``sig``."
     proc.send_signal(sig)
-    time.sleep(canc_timeout)
+    time.sleep(0.1)
     if not proc.poll():
         # TODO: why sometimes does SIGINT not work on teardown?
         # seems to happen only when trace logging enabled?
         proc.send_signal(_KILL_SIGNAL)
-    ret: int = proc.wait()
+    ret = proc.wait()
     assert ret
 
 
 # TODO: factor into @cm and move to `._testing`?
 @pytest.fixture
 def daemon(
-    debug_mode: bool,
     loglevel: str,
     testdir,
     reg_addr: tuple[str, int],
-    tpt_proto: str,
+):
-
-) -> subprocess.Popen:
     '''
     Run a daemon root actor as a separate actor-process tree and
     "remote registrar" for discovery-protocol related tests.
@@ -275,100 +200,28 @@ def daemon(
         loglevel: str = 'info'
 
     code: str = (
-        "import tractor; "
+            "import tractor; "
-        "tractor.run_daemon([], "
+            "tractor.run_daemon([], registry_addrs={reg_addrs}, loglevel={ll})"
-        "registry_addrs={reg_addrs}, "
-        "debug_mode={debug_mode}, "
-        "loglevel={ll})"
     ).format(
         reg_addrs=str([reg_addr]),
         ll="'{}'".format(loglevel) if loglevel else None,
-        debug_mode=debug_mode,
     )
     cmd: list[str] = [
         sys.executable,
         '-c', code,
     ]
-    # breakpoint()
     kwargs = {}
     if platform.system() == 'Windows':
         # without this, tests hang on windows forever
         kwargs['creationflags'] = subprocess.CREATE_NEW_PROCESS_GROUP
 
-    proc: subprocess.Popen = testdir.popen(
+    proc = testdir.popen(
         cmd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
         **kwargs,
     )
-
-    # UDS sockets are **really** fast to bind()/listen()/connect()
-    # so it's often required that we delay a bit more starting
-    # the first actor-tree..
-    if tpt_proto == 'uds':
-        global _PROC_SPAWN_WAIT
-        _PROC_SPAWN_WAIT = 0.6
-
-    time.sleep(_PROC_SPAWN_WAIT)
-
     assert not proc.returncode
+    time.sleep(_PROC_SPAWN_WAIT)
     yield proc
     sig_prog(proc, _INT_SIGNAL)
-
-    # XXX! yeah.. just be reaaal careful with this bc sometimes it
-    # can lock up on the `_io.BufferedReader` and hang..
-    stderr: str = proc.stderr.read().decode()
-    if stderr:
-        print(
-            f'Daemon actor tree produced STDERR:\n'
-            f'{proc.args}\n'
-            f'\n'
-            f'{stderr}\n'
-        )
-    if proc.returncode != -2:
-        raise RuntimeError(
-            'Daemon actor tree failed !?\n'
-            f'{proc.args}\n'
-        )
-
-
-# @pytest.fixture(autouse=True)
-# def shared_last_failed(pytestconfig):
-#     val = pytestconfig.cache.get("example/value", None)
-#     breakpoint()
-#     if val is None:
-#         pytestconfig.cache.set("example/value", val)
-#     return val
-
-
-# TODO: a way to let test scripts (like from `examples/`)
-# guarantee they won't `registry_addrs` collide!
-# -[ ] maybe use some kinda standard `def main()` arg-spec that
-#     we can introspect from a fixture that is called from the test
-#     body?
-# -[ ] test and figure out typing for below prototype! Bp
-#
-# @pytest.fixture
-# def set_script_runtime_args(
-#     reg_addr: tuple,
-# ) -> Callable[[...], None]:
-
-#     def import_n_partial_in_args_n_triorun(
-#         script: Path,  # under examples?
-#         **runtime_args,
-#     ) -> Callable[[], Any]:  # a `partial`-ed equiv of `trio.run()`
-
-#         # NOTE, below is taken from
-#         # `.test_advanced_faults.test_ipc_channel_break_during_stream`
-#         mod: ModuleType = import_path(
-#             examples_dir() / 'advanced_faults'
-#             / 'ipc_failure_during_stream.py',
-#             root=examples_dir(),
-#             consider_namespace_packages=False,
-#         )
-#         return partial(
-#             trio.run,
-#             partial(
-#                 mod.main,
-#                 **runtime_args,
-#             )
-#         )
-#     return import_n_partial_in_args_n_triorun

tests/test_advanced_faults.py

@@ -10,9 +10,6 @@ import pytest
 from _pytest.pathlib import import_path
 import trio
 import tractor
-from tractor import (
-    TransportClosed,
-)
 from tractor._testing import (
     examples_dir,
     break_ipc,
@@ -77,7 +74,6 @@ def test_ipc_channel_break_during_stream(
     spawn_backend: str,
     ipc_break: dict|None,
     pre_aclose_msgstream: bool,
-    tpt_proto: str,
 ):
     '''
     Ensure we can have an IPC channel break its connection during
@@ -95,7 +91,7 @@ def test_ipc_channel_break_during_stream(
         # non-`trio` spawners should never hit the hang condition that
         # requires the user to do ctl-c to cancel the actor tree.
         # expect_final_exc = trio.ClosedResourceError
-        expect_final_exc = TransportClosed
+        expect_final_exc = tractor.TransportClosed
 
     mod: ModuleType = import_path(
         examples_dir() / 'advanced_faults'
@@ -108,8 +104,6 @@ def test_ipc_channel_break_during_stream(
     # period" wherein the user eventually hits ctl-c to kill the
     # root-actor tree.
     expect_final_exc: BaseException = KeyboardInterrupt
-    expect_final_cause: BaseException|None = None
-
     if (
         # only expect EoC if trans is broken on the child side,
         ipc_break['break_child_ipc_after'] is not False
@@ -144,9 +138,6 @@ def test_ipc_channel_break_during_stream(
         # a user sending ctl-c by raising a KBI.
         if pre_aclose_msgstream:
             expect_final_exc = KeyboardInterrupt
-            if tpt_proto == 'uds':
-                expect_final_exc = TransportClosed
-                expect_final_cause = trio.BrokenResourceError
 
             # XXX OLD XXX
             # if child calls `MsgStream.aclose()` then expect EoC.
@@ -166,10 +157,6 @@ def test_ipc_channel_break_during_stream(
         if pre_aclose_msgstream:
             expect_final_exc = KeyboardInterrupt
 
-            if tpt_proto == 'uds':
-                expect_final_exc = TransportClosed
-                expect_final_cause = trio.BrokenResourceError
-
     # NOTE when the parent IPC side dies (even if the child does as well
     # but the child fails BEFORE the parent) we always expect the
     # IPC layer to raise a closed-resource, NEVER do we expect
@@ -182,8 +169,8 @@ def test_ipc_channel_break_during_stream(
         and
         ipc_break['break_child_ipc_after'] is False
     ):
+        # expect_final_exc = trio.ClosedResourceError
         expect_final_exc = tractor.TransportClosed
-        expect_final_cause = trio.ClosedResourceError
 
     # BOTH but, PARENT breaks FIRST
     elif (
@@ -194,8 +181,8 @@ def test_ipc_channel_break_during_stream(
             ipc_break['break_parent_ipc_after']
         )
     ):
+        # expect_final_exc = trio.ClosedResourceError
         expect_final_exc = tractor.TransportClosed
-        expect_final_cause = trio.ClosedResourceError
 
     with pytest.raises(
         expected_exception=(
@@ -211,7 +198,6 @@ def test_ipc_channel_break_during_stream(
                     start_method=spawn_backend,
                     loglevel=loglevel,
                     pre_close=pre_aclose_msgstream,
-                    tpt_proto=tpt_proto,
                     **ipc_break,
                 )
             )
@@ -234,15 +220,10 @@ def test_ipc_channel_break_during_stream(
                 )
             cause: Exception = tc.__cause__
             assert (
-                # type(cause) is trio.ClosedResourceError
+                type(cause) is trio.ClosedResourceError
-                type(cause) is expect_final_cause
+                and
-
+                cause.args[0] == 'another task closed this fd'
-                # TODO, should we expect a certain exc-message (per
-                # tpt) as well??
-                # and
-                # cause.args[0] == 'another task closed this fd'
             )
-
             raise
 
     # get raw instance from pytest wrapper

tests/test_discovery.py

@@ -7,9 +7,7 @@ import platform
 from functools import partial
 import itertools
 
-import psutil
 import pytest
-import subprocess
 import tractor
 from tractor._testing import tractor_test
 import trio
@@ -28,7 +26,7 @@ async def test_reg_then_unreg(reg_addr):
         portal = await n.start_actor('actor', enable_modules=[__name__])
         uid = portal.channel.uid
 
-        async with tractor.get_registry(reg_addr) as aportal:
+        async with tractor.get_registry(*reg_addr) as aportal:
             # this local actor should be the arbiter
             assert actor is aportal.actor
 
@@ -154,25 +152,15 @@ async def unpack_reg(actor_or_portal):
 async def spawn_and_check_registry(
     reg_addr: tuple,
     use_signal: bool,
-    debug_mode: bool = False,
     remote_arbiter: bool = False,
     with_streaming: bool = False,
-    maybe_daemon: tuple[
-        subprocess.Popen,
-        psutil.Process,
-    ]|None = None,
 
 ) -> None:
 
-    if maybe_daemon:
-        popen, proc = maybe_daemon
-        # breakpoint()
-
     async with tractor.open_root_actor(
         registry_addrs=[reg_addr],
-        debug_mode=debug_mode,
     ):
-        async with tractor.get_registry(reg_addr) as portal:
+        async with tractor.get_registry(*reg_addr) as portal:
             # runtime needs to be up to call this
             actor = tractor.current_actor()
 
@@ -188,11 +176,11 @@ async def spawn_and_check_registry(
                 extra = 2  # local root actor + remote arbiter
 
             # ensure current actor is registered
-            registry: dict = await get_reg()
+            registry = await get_reg()
             assert actor.uid in registry
 
             try:
-                async with tractor.open_nursery() as an:
+                async with tractor.open_nursery() as n:
                     async with trio.open_nursery(
                         strict_exception_groups=False,
                     ) as trion:
@@ -201,17 +189,17 @@ async def spawn_and_check_registry(
                         for i in range(3):
                             name = f'a{i}'
                             if with_streaming:
-                                portals[name] = await an.start_actor(
+                                portals[name] = await n.start_actor(
                                     name=name, enable_modules=[__name__])
 
                             else:  # no streaming
-                                portals[name] = await an.run_in_actor(
+                                portals[name] = await n.run_in_actor(
                                     trio.sleep_forever, name=name)
 
                         # wait on last actor to come up
                         async with tractor.wait_for_actor(name):
                             registry = await get_reg()
-                            for uid in an._children:
+                            for uid in n._children:
                                 assert uid in registry
 
                         assert len(portals) + extra == len(registry)
@@ -244,7 +232,6 @@ async def spawn_and_check_registry(
 @pytest.mark.parametrize('use_signal', [False, True])
 @pytest.mark.parametrize('with_streaming', [False, True])
 def test_subactors_unregister_on_cancel(
-    debug_mode: bool,
     start_method,
     use_signal,
     reg_addr,
@@ -261,7 +248,6 @@ def test_subactors_unregister_on_cancel(
                 spawn_and_check_registry,
                 reg_addr,
                 use_signal,
-                debug_mode=debug_mode,
                 remote_arbiter=False,
                 with_streaming=with_streaming,
             ),
@@ -271,8 +257,7 @@ def test_subactors_unregister_on_cancel(
 @pytest.mark.parametrize('use_signal', [False, True])
 @pytest.mark.parametrize('with_streaming', [False, True])
 def test_subactors_unregister_on_cancel_remote_daemon(
-    daemon: subprocess.Popen,
+    daemon,
-    debug_mode: bool,
     start_method,
     use_signal,
     reg_addr,
@@ -288,13 +273,8 @@ def test_subactors_unregister_on_cancel_remote_daemon(
                 spawn_and_check_registry,
                 reg_addr,
                 use_signal,
-                debug_mode=debug_mode,
                 remote_arbiter=True,
                 with_streaming=with_streaming,
-                maybe_daemon=(
-                    daemon,
-                    psutil.Process(daemon.pid)
-                ),
             ),
         )
 
@@ -320,7 +300,7 @@ async def close_chans_before_nursery(
     async with tractor.open_root_actor(
         registry_addrs=[reg_addr],
     ):
-        async with tractor.get_registry(reg_addr) as aportal:
+        async with tractor.get_registry(*reg_addr) as aportal:
             try:
                 get_reg = partial(unpack_reg, aportal)
 
@@ -393,7 +373,7 @@ def test_close_channel_explicit(
 
 @pytest.mark.parametrize('use_signal', [False, True])
 def test_close_channel_explicit_remote_arbiter(
-    daemon: subprocess.Popen,
+    daemon,
     start_method,
     use_signal,
     reg_addr,

tests/test_docs_examples.py

@@ -66,9 +66,6 @@ def run_example_in_subproc(
         # due to backpressure!!!
         proc = testdir.popen(
             cmdargs,
-            stdin=subprocess.PIPE,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
             **kwargs,
         )
         assert not proc.returncode
@@ -122,14 +119,10 @@ def test_example(
         code = ex.read()
 
         with run_example_in_subproc(code) as proc:
-            err = None
+            proc.wait()
-            try:
+            err, _ = proc.stderr.read(), proc.stdout.read()
-                if not proc.poll():
+            # print(f'STDERR: {err}')
-                    _, err = proc.communicate(timeout=15)
+            # print(f'STDOUT: {out}')
-
-            except subprocess.TimeoutExpired as e:
-                proc.kill()
-                err = e.stderr
 
             # if we get some gnarly output let's aggregate and raise
             if err:

tests/test_ext_types_msgspec.py

@@ -5,7 +5,6 @@ Low-level functional audits for our
 B~)
 
 '''
-from __future__ import annotations
 from contextlib import (
     contextmanager as cm,
     # nullcontext,
@@ -21,7 +20,7 @@ from msgspec import (
     # structs,
     # msgpack,
     Raw,
-    Struct,
+    # Struct,
     ValidationError,
 )
 import pytest
@@ -47,11 +46,6 @@ from tractor.msg import (
     apply_codec,
     current_codec,
 )
-from tractor.msg._codec import (
-    default_builtins,
-    mk_dec_hook,
-    mk_codec_from_spec,
-)
 from tractor.msg.types import (
     log,
     Started,
@@ -749,143 +743,6 @@ def test_ext_types_over_ipc(
         assert exc.boxed_type is TypeError
 
 
-'''
-Test the auto enc & dec hooks
-
-Create a codec which will work for:
-    - builtins
-    - custom types
-    - lists of custom types
-'''
-
-
-class BytesTestClass(Struct, tag=True):
-    raw: bytes
-
-    def encode(self) -> bytes:
-        return self.raw
-
-    @classmethod
-    def from_bytes(self, raw: bytes) -> BytesTestClass:
-        return BytesTestClass(raw=raw)
-
-
-class StrTestClass(Struct, tag=True):
-    s: str
-
-    def encode(self) -> str:
-        return self.s
-
-    @classmethod
-    def from_str(self, s: str) -> StrTestClass:
-        return StrTestClass(s=s)
-
-
-class IntTestClass(Struct, tag=True):
-    num: int
-
-    def encode(self) -> int:
-        return self.num
-
-    @classmethod
-    def from_int(self, num: int) -> IntTestClass:
-        return IntTestClass(num=num)
-
-
-builtins = tuple((
-    builtin
-    for builtin in default_builtins
-    if builtin is not list
-))
-
-TestClasses = (BytesTestClass, StrTestClass, IntTestClass)
-
-
-TestSpec = (
-    *TestClasses, list[Union[*TestClasses]]
-)
-
-
-test_codec = mk_codec_from_spec(
-    spec=TestSpec
-)
-
-
-@tractor.context
-async def child_custom_codec(
-    ctx: tractor.Context,
-    msgs: list[Union[*TestSpec]],
-):
-    '''
-    Apply codec and send all msgs passed through stream
-
-    '''
-    with (
-        apply_codec(test_codec),
-        limit_plds(
-            test_codec.pld_spec,
-            dec_hook=mk_dec_hook(TestSpec),
-            ext_types=TestSpec + builtins
-        ),
-    ):
-        await ctx.started(None)
-        async with ctx.open_stream() as stream:
-            for msg in msgs:
-                await stream.send(msg)
-
-
-def test_multi_custom_codec():
-    '''
-    Open subactor setup codec and pld_rx and wait to receive & assert from
-    stream
-
-    '''
-    msgs = [
-        None,
-        True, False,
-        0xdeadbeef,
-        .42069,
-        b'deadbeef',
-        BytesTestClass(raw=b'deadbeef'),
-        StrTestClass(s='deadbeef'),
-        IntTestClass(num=0xdeadbeef),
-        [
-            BytesTestClass(raw=b'deadbeef'),
-            StrTestClass(s='deadbeef'),
-            IntTestClass(num=0xdeadbeef),
-        ]
-    ]
-
-    async def main():
-        async with tractor.open_nursery() as an:
-            p: tractor.Portal = await an.start_actor(
-                'child',
-                enable_modules=[__name__],
-            )
-            async with (
-                p.open_context(
-                    child_custom_codec,
-                    msgs=msgs,
-                ) as (ctx, _),
-                ctx.open_stream() as ipc
-            ):
-                with (
-                    apply_codec(test_codec),
-                    limit_plds(
-                        test_codec.pld_spec,
-                        dec_hook=mk_dec_hook(TestSpec),
-                        ext_types=TestSpec + builtins
-                    )
-                ):
-                    msg_iter = iter(msgs)
-                    async for recv_msg in ipc:
-                        assert recv_msg == next(msg_iter)
-
-            await p.cancel_actor()
-
-    trio.run(main)
-
-
 # def chk_pld_type(
 #     payload_spec: Type[Struct]|Any,
 #     pld: Any,

tests/test_inter_peer_cancellation.py

@@ -871,7 +871,7 @@ async def serve_subactors(
                 )
                 await ipc.send((
                     peer.chan.uid,
-                    peer.chan.raddr.unwrap(),
+                    peer.chan.raddr,
                 ))
 
         print('Spawner exiting spawn serve loop!')

tests/test_local.py

@@ -38,7 +38,7 @@ async def test_self_is_registered_localportal(reg_addr):
     "Verify waiting on the arbiter to register itself using a local portal."
     actor = tractor.current_actor()
     assert actor.is_arbiter
-    async with tractor.get_registry(reg_addr) as portal:
+    async with tractor.get_registry(*reg_addr) as portal:
         assert isinstance(portal, tractor._portal.LocalPortal)
 
         with trio.fail_after(0.2):

tests/test_multi_program.py

@@ -32,7 +32,7 @@ def test_abort_on_sigint(daemon):
 @tractor_test
 async def test_cancel_remote_arbiter(daemon, reg_addr):
     assert not tractor.current_actor().is_arbiter
-    async with tractor.get_registry(reg_addr) as portal:
+    async with tractor.get_registry(*reg_addr) as portal:
         await portal.cancel_actor()
 
     time.sleep(0.1)
@@ -41,7 +41,7 @@ async def test_cancel_remote_arbiter(daemon, reg_addr):
 
     # no arbiter socket should exist
     with pytest.raises(OSError):
-        async with tractor.get_registry(reg_addr) as portal:
+        async with tractor.get_registry(*reg_addr) as portal:
             pass
 
 

tests/test_resource_cache.py

@@ -100,29 +100,16 @@ async def streamer(
 @acm
 async def open_stream() -> Awaitable[tractor.MsgStream]:
 
-    try:
+    async with tractor.open_nursery() as tn:
-        async with tractor.open_nursery() as an:
+        portal = await tn.start_actor('streamer', enable_modules=[__name__])
-            portal = await an.start_actor(
+        async with (
-                'streamer',
+            portal.open_context(streamer) as (ctx, first),
-                enable_modules=[__name__],
+            ctx.open_stream() as stream,
-            )
+        ):
-            async with (
+            yield stream
-                portal.open_context(streamer) as (ctx, first),
-                ctx.open_stream() as stream,
-            ):
-                yield stream
 
-            print('Cancelling streamer')
+        await portal.cancel_actor()
-            await portal.cancel_actor()
+    print('CANCELLED STREAMER')
-            print('Cancelled streamer')
-
-    except Exception as err:
-        print(
-            f'`open_stream()` errored?\n'
-            f'{err!r}\n'
-        )
-        await tractor.pause(shield=True)
-        raise err
 
 
 @acm
@@ -145,28 +132,19 @@ async def maybe_open_stream(taskname: str):
             yield stream
 
 
-def test_open_local_sub_to_stream(
+def test_open_local_sub_to_stream():
-    debug_mode: bool,
-):
     '''
     Verify a single inter-actor stream can can be fanned-out shared to
-    N local tasks using `trionics.maybe_open_context()`.
+    N local tasks using ``trionics.maybe_open_context():``.
 
     '''
-    timeout: float = 3.6
+    timeout: float = 3.6 if platform.system() != "Windows" else 10
-    if platform.system() == "Windows":
-        timeout: float = 10
-
-    if debug_mode:
-        timeout = 999
 
     async def main():
 
         full = list(range(1000))
 
         async def get_sub_and_pull(taskname: str):
-
-            stream: tractor.MsgStream
             async with (
                 maybe_open_stream(taskname) as stream,
             ):
@@ -187,27 +165,17 @@ def test_open_local_sub_to_stream(
                 assert set(seq).issubset(set(full))
             print(f'{taskname} finished')
 
-        with trio.fail_after(timeout) as cs:
+        with trio.fail_after(timeout):
             # TODO: turns out this isn't multi-task entrant XD
             # We probably need an indepotent entry semantic?
-            async with tractor.open_root_actor(
+            async with tractor.open_root_actor():
-                debug_mode=debug_mode,
-            ):
                 async with (
-                    trio.open_nursery() as tn,
+                    trio.open_nursery() as nurse,
                 ):
                     for i in range(10):
-                        tn.start_soon(
+                        nurse.start_soon(get_sub_and_pull, f'task_{i}')
-                            get_sub_and_pull,
-                            f'task_{i}',
-                        )
                         await trio.sleep(0.001)
 
                 print('all consumer tasks finished')
 
-        if cs.cancelled_caught:
-            pytest.fail(
-                'Should NOT time out in `open_root_actor()` ?'
-            )
-
     trio.run(main)

tests/test_ring_pubsub.py

@@ -120,24 +120,21 @@ async def open_pubsub_test_actors(
                     publisher_child,
                     batch_size=batch_size
                 ) as (long_sctx, _),
-
-                open_ringbufs(ring_names) as tokens,
-
-                gather_contexts([
-                    open_sub_channel_at('sub', ring)
-                    for ring in tokens
-                ]),
-                gather_contexts([
-                    open_pub_channel_at('pub', ring)
-                    for ring in tokens
-                ]),
-                sub_portal.open_context(subscribe_range, size=size) as (rctx, _),
-                pub_portal.open_context(publish_range, size=size) as (sctx, _)
             ):
-                yield
+                with open_ringbufs(ring_names) as tokens:
-
+                    async with (
-                await rctx.wait_for_result()
+                        gather_contexts([
-                await sctx.wait_for_result()
+                            open_sub_channel_at('sub', ring)
+                            for ring in tokens
+                        ]),
+                        gather_contexts([
+                            open_pub_channel_at('pub', ring)
+                            for ring in tokens
+                        ]),
+                        sub_portal.open_context(subscribe_range, size=size) as (rctx, _),
+                        pub_portal.open_context(publish_range, size=size) as (sctx, _)
+                    ):
+                        yield
 
                 await long_sctx.cancel()
                 await long_rctx.cancel()

tests/test_ringbuf.py

@@ -3,7 +3,6 @@ import hashlib
 
 import trio
 import pytest
-
 import tractor
 from tractor.ipc._ringbuf import (
     open_ringbuf,
@@ -270,24 +269,19 @@ def test_receiver_max_bytes():
     msg = generate_single_byte_msgs(100)
     msgs = []
 
-    rb_common = {
-        'cleanup': False,
-        'is_ipc': False
-    }
-
     async def main():
         async with (
+            tractor.open_nursery(),
             open_ringbuf(
                 'test_ringbuf_max_bytes',
-                buf_size=10,
+                buf_size=10
-                is_ipc=False
             ) as token,
 
             trio.open_nursery() as n,
 
-            attach_to_ringbuf_sender(token, **rb_common) as sender,
+            attach_to_ringbuf_sender(token, cleanup=False) as sender,
 
-            attach_to_ringbuf_receiver(token, **rb_common) as receiver
+            attach_to_ringbuf_receiver(token, cleanup=False) as receiver
         ):
             async def _send_and_close():
                 await sender.send_all(msg)

tests/test_root_runtime.py

@@ -1,85 +0,0 @@
-'''
-Runtime boot/init sanity.
-
-'''
-
-import pytest
-import trio
-
-import tractor
-from tractor._exceptions import RuntimeFailure
-
-
-@tractor.context
-async def open_new_root_in_sub(
-    ctx: tractor.Context,
-) -> None:
-
-    async with tractor.open_root_actor():
-        pass
-
-
-@pytest.mark.parametrize(
-    'open_root_in',
-    ['root', 'sub'],
-    ids='open_2nd_root_in={}'.format,
-)
-def test_only_one_root_actor(
-    open_root_in: str,
-    reg_addr: tuple,
-    debug_mode: bool
-):
-    '''
-    Verify we specially fail whenever more then one root actor
-    is attempted to be opened within an already opened tree.
-
-    '''
-    async def main():
-        async with tractor.open_nursery() as an:
-
-            if open_root_in == 'root':
-                async with tractor.open_root_actor(
-                    registry_addrs=[reg_addr],
-                ):
-                    pass
-
-            ptl: tractor.Portal = await an.start_actor(
-                name='bad_rooty_boi',
-                enable_modules=[__name__],
-            )
-
-            async with ptl.open_context(
-                open_new_root_in_sub,
-            ) as (ctx, first):
-                pass
-
-    if open_root_in == 'root':
-        with pytest.raises(
-            RuntimeFailure
-        ) as excinfo:
-            trio.run(main)
-
-    else:
-        with pytest.raises(
-            tractor.RemoteActorError,
-        ) as excinfo:
-            trio.run(main)
-
-        assert excinfo.value.boxed_type is RuntimeFailure
-
-
-def test_implicit_root_via_first_nursery(
-    reg_addr: tuple,
-    debug_mode: bool
-):
-    '''
-    The first `ActorNursery` open should implicitly call
-    `_root.open_root_actor()`.
-
-    '''
-    async def main():
-        async with tractor.open_nursery() as an:
-            assert an._implicit_runtime_started
-            assert tractor.current_actor().aid.name == 'root'
-
-    trio.run(main)

tests/test_spawning.py

@@ -2,7 +2,6 @@
 Spawning basics
 
 """
-from functools import partial
 from typing import (
     Any,
 )
@@ -13,99 +12,74 @@ import tractor
 
 from tractor._testing import tractor_test
 
-data_to_pass_down = {
+data_to_pass_down = {'doggy': 10, 'kitty': 4}
-    'doggy': 10,
-    'kitty': 4,
-}
 
 
 async def spawn(
-    should_be_root: bool,
+    is_arbiter: bool,
     data: dict,
     reg_addr: tuple[str, int],
-
-    debug_mode: bool = False,
 ):
+    namespaces = [__name__]
+
     await trio.sleep(0.1)
-    actor = tractor.current_actor(err_on_no_runtime=False)
 
-    if should_be_root:
+    async with tractor.open_root_actor(
-        assert actor is None  # no runtime yet
+        arbiter_addr=reg_addr,
-        async with (
+    ):
-            tractor.open_root_actor(
+        actor = tractor.current_actor()
-                arbiter_addr=reg_addr,
+        assert actor.is_arbiter == is_arbiter
-            ),
+        data = data_to_pass_down
-            tractor.open_nursery() as an,
-        ):
-            # now runtime exists
-            actor: tractor.Actor = tractor.current_actor()
-            assert actor.is_arbiter == should_be_root
 
-            # spawns subproc here
+        if actor.is_arbiter:
-            portal: tractor.Portal = await an.run_in_actor(
+            async with tractor.open_nursery() as nursery:
-                fn=spawn,
 
-                # spawning args
+                # forks here
-                name='sub-actor',
+                portal = await nursery.run_in_actor(
-                enable_modules=[__name__],
+                    spawn,
+                    is_arbiter=False,
+                    name='sub-actor',
+                    data=data,
+                    reg_addr=reg_addr,
+                    enable_modules=namespaces,
+                )
 
-                # passed to a subactor-recursive RPC invoke
+                assert len(nursery._children) == 1
-                # of this same `spawn()` fn.
+                assert portal.channel.uid in tractor.current_actor()._peers
-                should_be_root=False,
+                # be sure we can still get the result
-                data=data_to_pass_down,
+                result = await portal.result()
-                reg_addr=reg_addr,
+                assert result == 10
-            )
+                return result
-
+        else:
-            assert len(an._children) == 1
+            return 10
-            assert (
-                portal.channel.uid
-                in
-                tractor.current_actor().ipc_server._peers
-            )
-
-            # get result from child subactor
-            result = await portal.result()
-            assert result == 10
-            return result
-    else:
-        assert actor.is_arbiter == should_be_root
-        return 10
 
 
-def test_run_in_actor_same_func_in_child(
+def test_local_arbiter_subactor_global_state(
-    reg_addr: tuple,
+    reg_addr,
-    debug_mode: bool,
 ):
     result = trio.run(
-        partial(
+        spawn,
-            spawn,
+        True,
-            should_be_root=True,
+        data_to_pass_down,
-            data=data_to_pass_down,
+        reg_addr,
-            reg_addr=reg_addr,
-            debug_mode=debug_mode,
-        )
     )
     assert result == 10
 
 
 async def movie_theatre_question():
-    '''
+    """A question asked in a dark theatre, in a tangent
-    A question asked in a dark theatre, in a tangent
     (errr, I mean different) process.
-
+    """
-    '''
     return 'have you ever seen a portal?'
 
 
 @tractor_test
 async def test_movie_theatre_convo(start_method):
-    '''
+    """The main ``tractor`` routine.
-    The main ``tractor`` routine.
+    """
+    async with tractor.open_nursery() as n:
 
-    '''
+        portal = await n.start_actor(
-    async with tractor.open_nursery(debug_mode=True) as an:
-
-        portal = await an.start_actor(
             'frank',
             # enable the actor to run funcs from this current module
             enable_modules=[__name__],
@@ -144,8 +118,8 @@ async def test_most_beautiful_word(
     with trio.fail_after(1):
         async with tractor.open_nursery(
             debug_mode=debug_mode,
-        ) as an:
+        ) as n:
-            portal = await an.run_in_actor(
+            portal = await n.run_in_actor(
                 cellar_door,
                 return_value=return_value,
                 name='some_linguist',

tests/test_trioisms.py

@@ -180,8 +180,7 @@ def test_acm_embedded_nursery_propagates_enter_err(
         with tractor.devx.maybe_open_crash_handler(
             pdb=debug_mode,
         ) as bxerr:
-            if bxerr:
+            assert not bxerr.value
-                assert not bxerr.value
 
             async with (
                 wraps_tn_that_always_cancels() as tn,

tractor/_addr.py

@@ -1,282 +0,0 @@
-# tractor: structured concurrent "actors".
-# Copyright 2018-eternity Tyler Goodlet.
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Affero General Public License for more details.
-
-# You should have received a copy of the GNU Affero General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-from __future__ import annotations
-from uuid import uuid4
-from typing import (
-    Protocol,
-    ClassVar,
-    Type,
-    TYPE_CHECKING,
-)
-
-from bidict import bidict
-from trio import (
-    SocketListener,
-)
-
-from .log import get_logger
-from ._state import (
-    _def_tpt_proto,
-)
-from .ipc._tcp import TCPAddress
-from .ipc._uds import UDSAddress
-
-if TYPE_CHECKING:
-    from ._runtime import Actor
-
-log = get_logger(__name__)
-
-
-# TODO, maybe breakout the netns key to a struct?
-# class NetNs(Struct)[str, int]:
-#     ...
-
-# TODO, can't we just use a type alias
-# for this? namely just some `tuple[str, int, str, str]`?
-#
-# -[ ] would also just be simpler to keep this as SockAddr[tuple]
-#     or something, implying it's just a simple pair of values which can
-#     presumably be mapped to all transports?
-# -[ ] `pydoc socket.socket.getsockname()` delivers a 4-tuple for
-#     ipv6 `(hostaddr, port, flowinfo, scope_id)`.. so how should we
-#     handle that?
-# -[ ] as a further alternative to this wrap()/unwrap() approach we
-#     could just implement `enc/dec_hook()`s for the `Address`-types
-#     and just deal with our internal objs directly and always and
-#     leave it to the codec layer to figure out marshalling?
-#    |_ would mean only one spot to do the `.unwrap()` (which we may
-#       end up needing to call from the hook()s anyway?)
-# -[x] rename to `UnwrappedAddress[Descriptor]` ??
-#    seems like the right name as per,
-#    https://www.geeksforgeeks.org/introduction-to-address-descriptor/
-#
-UnwrappedAddress = (
-    # tcp/udp/uds
-    tuple[
-        str,  # host/domain(tcp), filesys-dir(uds)
-        int|str,  # port/path(uds)
-    ]
-    # ?TODO? should we also include another 2 fields from
-    # our `Aid` msg such that we include the runtime `Actor.uid`
-    # of `.name` and `.uuid`?
-    # - would ensure uniqueness across entire net?
-    # - allows for easier runtime-level filtering of "actors by
-    #   service name"
-)
-
-
-# TODO, maybe rename to `SocketAddress`?
-class Address(Protocol):
-    proto_key: ClassVar[str]
-    unwrapped_type: ClassVar[UnwrappedAddress]
-
-    # TODO, i feel like an `.is_bound()` is a better thing to
-    # support?
-    # Lke, what use does this have besides a noop and if it's not
-    # valid why aren't we erroring on creation/use?
-    @property
-    def is_valid(self) -> bool:
-        ...
-
-    # TODO, maybe `.netns` is a better name?
-    @property
-    def namespace(self) -> tuple[str, int]|None:
-        '''
-        The if-available, OS-specific "network namespace" key.
-
-        '''
-        ...
-
-    @property
-    def bindspace(self) -> str:
-        '''
-        Deliver the socket address' "bindable space" from
-        a `socket.socket.bind()` and thus from the perspective of
-        specific transport protocol domain.
-
-        I.e. for most (layer-4) network-socket protocols this is
-        normally the ipv4/6 address, for UDS this is normally
-        a filesystem (sub-directory).
-
-        For (distributed) network protocols this is normally the routing
-        layer's domain/(ip-)address, though it might also include a "network namespace"
-        key different then the default.
-
-        For local-host-only transports this is either an explicit
-        namespace (with types defined by the OS: netns, Cgroup, IPC,
-        pid, etc. on linux) or failing that the sub-directory in the
-        filesys in which socket/shm files are located *under*.
-
-        '''
-        ...
-
-    @classmethod
-    def from_addr(cls, addr: UnwrappedAddress) -> Address:
-        ...
-
-    def unwrap(self) -> UnwrappedAddress:
-        '''
-        Deliver the underying minimum field set in
-        a primitive python data type-structure.
-        '''
-        ...
-
-    @classmethod
-    def get_random(
-        cls,
-        current_actor: Actor,
-        bindspace: str|None = None,
-    ) -> Address:
-        ...
-
-    # TODO, this should be something like a `.get_def_registar_addr()`
-    # or similar since,
-    # - it should be a **host singleton** (not root/tree singleton)
-    # - we **only need this value** when one isn't provided to the
-    #   runtime at boot and we want to implicitly provide a host-wide
-    #   registrar.
-    # - each rooted-actor-tree should likely have its own
-    #   micro-registry (likely the root being it), also see
-    @classmethod
-    def get_root(cls) -> Address:
-        ...
-
-    def __repr__(self) -> str:
-        ...
-
-    def __eq__(self, other) -> bool:
-        ...
-
-    async def open_listener(
-        self,
-        **kwargs,
-    ) -> SocketListener:
-        ...
-
-    async def close_listener(self):
-        ...
-
-
-_address_types: bidict[str, Type[Address]] = {
-    'tcp': TCPAddress,
-    'uds': UDSAddress
-}
-
-
-# TODO! really these are discovery sys default addrs ONLY useful for
-# when none is provided to a root actor on first boot.
-_default_lo_addrs: dict[
-    str,
-    UnwrappedAddress
-] = {
-    'tcp': TCPAddress.get_root().unwrap(),
-    'uds': UDSAddress.get_root().unwrap(),
-}
-
-
-def get_address_cls(name: str) -> Type[Address]:
-    return _address_types[name]
-
-
-def is_wrapped_addr(addr: any) -> bool:
-    return type(addr) in _address_types.values()
-
-
-def mk_uuid() -> str:
-    '''
-    Encapsulate creation of a uuid4 as `str` as used
-    for creating `Actor.uid: tuple[str, str]` and/or
-    `.msg.types.Aid`.
-
-    '''
-    return str(uuid4())
-
-
-def wrap_address(
-    addr: UnwrappedAddress
-) -> Address:
-    '''
-    Wrap an `UnwrappedAddress` as an `Address`-type based
-    on matching builtin python data-structures which we adhoc
-    use for each.
-
-    XXX NOTE, careful care must be placed to ensure
-    `UnwrappedAddress` cases are **definitely unique** otherwise the
-    wrong transport backend may be loaded and will break many
-    low-level things in our runtime in a not-fun-to-debug way!
-
-    XD
-
-    '''
-    if is_wrapped_addr(addr):
-        return addr
-
-    cls: Type|None = None
-    # if 'sock' in addr[0]:
-    #     import pdbp; pdbp.set_trace()
-    match addr:
-
-        # classic network socket-address as tuple/list
-        case (
-            (str(), int())
-            |
-            [str(), int()]
-        ):
-            cls = TCPAddress
-
-        case (
-            # (str()|Path(), str()|Path()),
-            # ^TODO? uhh why doesn't this work!?
-
-            (_, filename)
-        ) if type(filename) is str:
-            cls = UDSAddress
-
-        # likely an unset UDS or TCP reg address as defaulted in
-        # `_state._runtime_vars['_root_mailbox']`
-        #
-        # TODO? figure out when/if we even need this?
-        case (
-            None
-            |
-            [None, None]
-        ):
-            cls: Type[Address] = get_address_cls(_def_tpt_proto)
-            addr: UnwrappedAddress = cls.get_root().unwrap()
-
-        case _:
-            # import pdbp; pdbp.set_trace()
-            raise TypeError(
-                f'Can not wrap unwrapped-address ??\n'
-                f'type(addr): {type(addr)!r}\n'
-                f'addr: {addr!r}\n'
-            )
-
-    return cls.from_addr(addr)
-
-
-def default_lo_addrs(
-    transports: list[str],
-) -> list[Type[Address]]:
-    '''
-    Return the default, host-singleton, registry address
-    for an input transport key set.
-
-    '''
-    return [
-        _default_lo_addrs[transport]
-        for transport in transports
-    ]

tractor/_child.py

@@ -31,12 +31,8 @@ def parse_uid(arg):
     return str(name), str(uuid)  # ensures str encoding
 
 def parse_ipaddr(arg):
-    try:
+    host, port = literal_eval(arg)
-        return literal_eval(arg)
+    return (str(host), int(port))
-
-    except (ValueError, SyntaxError):
-        # UDS: try to interpret as a straight up str
-        return arg
 
 
 if __name__ == "__main__":
@@ -50,8 +46,8 @@ if __name__ == "__main__":
     args = parser.parse_args()
 
     subactor = Actor(
-        name=args.uid[0],
+        args.uid[0],
-        uuid=args.uid[1],
+        uid=args.uid[1],
         loglevel=args.loglevel,
         spawn_method="trio"
     )

tractor/_context.py

@@ -105,7 +105,7 @@ from ._state import (
 if TYPE_CHECKING:
     from ._portal import Portal
     from ._runtime import Actor
-    from .ipc._transport import MsgTransport
+    from .ipc import MsgTransport
     from .devx._frame_stack import (
         CallerInfo,
     )
@@ -366,7 +366,7 @@ class Context:
             # f'   ---\n'
             f' |_ipc: {self.dst_maddr}\n'
             # f'   dst_maddr{ds}{self.dst_maddr}\n'
-            f"   uid{ds}'{self.chan.aid}'\n"
+            f"   uid{ds}'{self.chan.uid}'\n"
             f"   cid{ds}'{self.cid}'\n"
             # f'   ---\n'
             f'\n'
@@ -859,10 +859,19 @@ class Context:
     @property
     def dst_maddr(self) -> str:
         chan: Channel = self.chan
+        dst_addr, dst_port = chan.raddr
         trans: MsgTransport = chan.transport
         # cid: str = self.cid
         # cid_head, cid_tail = cid[:6], cid[-6:]
-        return trans.maddr
+        return (
+            f'/ipv4/{dst_addr}'
+            f'/{trans.name_key}/{dst_port}'
+            # f'/{self.chan.uid[0]}'
+            # f'/{self.cid}'
+
+            # f'/cid={cid_head}..{cid_tail}'
+            # TODO: ? not use this ^ right ?
+        )
 
     dmaddr = dst_maddr
 
@@ -945,10 +954,10 @@ class Context:
         reminfo: str = (
             # ' =>\n'
             # f'Context.cancel() => {self.chan.uid}\n'
-            f'\n'
             f'c)=> {self.chan.uid}\n'
-            f'   |_[{self.dst_maddr}\n'
+            # f'{self.chan.uid}\n'
-            f'     >>{self.repr_rpc}\n'
+            f'  |_ @{self.dst_maddr}\n'
+            f'    >> {self.repr_rpc}\n'
             # f'    >> {self._nsf}() -> {codec}[dict]:\n\n'
             # TODO: pull msg-type from spec re #320
         )

tractor/_discovery.py

@@ -30,11 +30,6 @@ from contextlib import asynccontextmanager as acm
 from tractor.log import get_logger
 from .trionics import gather_contexts
 from .ipc import _connect_chan, Channel
-from ._addr import (
-    UnwrappedAddress,
-    Address,
-    wrap_address
-)
 from ._portal import (
     Portal,
     open_portal,
@@ -43,12 +38,10 @@ from ._portal import (
 from ._state import (
     current_actor,
     _runtime_vars,
-    _def_tpt_proto,
 )
 
 if TYPE_CHECKING:
     from ._runtime import Actor
-    from .ipc._server import IPCServer
 
 
 log = get_logger(__name__)
@@ -56,7 +49,9 @@ log = get_logger(__name__)
 
 @acm
 async def get_registry(
-    addr: UnwrappedAddress|None = None,
+    host: str,
+    port: int,
+
 ) -> AsyncGenerator[
     Portal | LocalPortal | None,
     None,
@@ -74,15 +69,13 @@ async def get_registry(
         # (likely a re-entrant call from the arbiter actor)
         yield LocalPortal(
             actor,
-            Channel(transport=None)
+            Channel((host, port))
-            # ^XXX, we DO NOT actually provide nor connect an
-            # underlying transport since this is merely an API shim.
         )
     else:
         # TODO: try to look pre-existing connection from
-        # `IPCServer._peers` and use it instead?
+        # `Actor._peers` and use it instead?
         async with (
-            _connect_chan(addr) as chan,
+            _connect_chan(host, port) as chan,
             open_portal(chan) as regstr_ptl,
         ):
             yield regstr_ptl
@@ -96,10 +89,11 @@ async def get_root(
 
     # TODO: rename mailbox to `_root_maddr` when we finally
     # add and impl libp2p multi-addrs?
-    addr = _runtime_vars['_root_mailbox']
+    host, port = _runtime_vars['_root_mailbox']
+    assert host is not None
 
     async with (
-        _connect_chan(addr) as chan,
+        _connect_chan(host, port) as chan,
         open_portal(chan, **kwargs) as portal,
     ):
         yield portal
@@ -112,22 +106,22 @@ def get_peer_by_name(
 ) -> list[Channel]|None:  # at least 1
     '''
     Scan for an existing connection (set) to a named actor
-    and return any channels from `IPCServer._peers: dict`.
+    and return any channels from `Actor._peers`.
 
     This is an optimization method over querying the registrar for
     the same info.
 
     '''
     actor: Actor = current_actor()
-    server: IPCServer = actor.ipc_server
+    to_scan: dict[tuple, list[Channel]] = actor._peers.copy()
-    to_scan: dict[tuple, list[Channel]] = server._peers.copy()
 
     # TODO: is this ever needed? creates a duplicate channel on actor._peers
     # when multiple find_actor calls are made to same actor from a single ctx
     # which causes actor exit to hang waiting forever on
     # `actor._no_more_peers.wait()` in `_runtime.async_main`
+
     # pchan: Channel|None = actor._parent_chan
-    # if pchan:
+    # if pchan and pchan.uid not in to_scan:
     #     to_scan[pchan.uid].append(pchan)
 
     for aid, chans in to_scan.items():
@@ -146,10 +140,10 @@ def get_peer_by_name(
 @acm
 async def query_actor(
     name: str,
-    regaddr: UnwrappedAddress|None = None,
+    regaddr: tuple[str, int]|None = None,
 
 ) -> AsyncGenerator[
-    UnwrappedAddress|None,
+    tuple[str, int]|None,
     None,
 ]:
     '''
@@ -175,31 +169,31 @@ async def query_actor(
         return
 
     reg_portal: Portal
-    regaddr: Address = wrap_address(regaddr) or actor.reg_addrs[0]
+    regaddr: tuple[str, int] = regaddr or actor.reg_addrs[0]
-    async with get_registry(regaddr) as reg_portal:
+    async with get_registry(*regaddr) as reg_portal:
         # TODO: return portals to all available actors - for now
         # just the last one that registered
-        addr: UnwrappedAddress = await reg_portal.run_from_ns(
+        sockaddr: tuple[str, int] = await reg_portal.run_from_ns(
             'self',
             'find_actor',
             name=name,
         )
-        yield addr
+        yield sockaddr
 
 
 @acm
 async def maybe_open_portal(
-    addr: UnwrappedAddress,
+    addr: tuple[str, int],
     name: str,
 ):
     async with query_actor(
         name=name,
         regaddr=addr,
-    ) as addr:
+    ) as sockaddr:
         pass
 
-    if addr:
+    if sockaddr:
-        async with _connect_chan(addr) as chan:
+        async with _connect_chan(*sockaddr) as chan:
             async with open_portal(chan) as portal:
                 yield portal
     else:
@@ -209,8 +203,7 @@ async def maybe_open_portal(
 @acm
 async def find_actor(
     name: str,
-    registry_addrs: list[UnwrappedAddress]|None = None,
+    registry_addrs: list[tuple[str, int]]|None = None,
-    enable_transports: list[str] = [_def_tpt_proto],
 
     only_first: bool = True,
     raise_on_none: bool = False,
@@ -237,15 +230,15 @@ async def find_actor(
         # XXX NOTE: make sure to dynamically read the value on
         # every call since something may change it globally (eg.
         # like in our discovery test suite)!
-        from ._addr import default_lo_addrs
+        from . import _root
         registry_addrs = (
             _runtime_vars['_registry_addrs']
             or
-            default_lo_addrs(enable_transports)
+            _root._default_lo_addrs
         )
 
     maybe_portals: list[
-        AsyncContextManager[UnwrappedAddress]
+        AsyncContextManager[tuple[str, int]]
     ] = list(
         maybe_open_portal(
             addr=addr,
@@ -287,7 +280,7 @@ async def find_actor(
 @acm
 async def wait_for_actor(
     name: str,
-    registry_addr: UnwrappedAddress | None = None,
+    registry_addr: tuple[str, int] | None = None,
 
 ) -> AsyncGenerator[Portal, None]:
     '''
@@ -304,7 +297,7 @@ async def wait_for_actor(
             yield peer_portal
             return
 
-    regaddr: UnwrappedAddress = (
+    regaddr: tuple[str, int] = (
         registry_addr
         or
         actor.reg_addrs[0]
@@ -312,8 +305,8 @@ async def wait_for_actor(
     # TODO: use `.trionics.gather_contexts()` like
     # above in `find_actor()` as well?
     reg_portal: Portal
-    async with get_registry(regaddr) as reg_portal:
+    async with get_registry(*regaddr) as reg_portal:
-        addrs = await reg_portal.run_from_ns(
+        sockaddrs = await reg_portal.run_from_ns(
             'self',
             'wait_for_actor',
             name=name,
@@ -321,8 +314,8 @@ async def wait_for_actor(
 
         # get latest registered addr by default?
         # TODO: offer multi-portal yields in multi-homed case?
-        addr: UnwrappedAddress = addrs[-1]
+        sockaddr: tuple[str, int] = sockaddrs[-1]
 
-        async with _connect_chan(addr) as chan:
+        async with _connect_chan(*sockaddr) as chan:
             async with open_portal(chan) as portal:
                 yield portal

tractor/_entry.py

@@ -37,7 +37,6 @@ from .log import (
 from . import _state
 from .devx import _debug
 from .to_asyncio import run_as_asyncio_guest
-from ._addr import UnwrappedAddress
 from ._runtime import (
     async_main,
     Actor,
@@ -53,10 +52,10 @@ log = get_logger(__name__)
 def _mp_main(
 
     actor: Actor,
-    accept_addrs: list[UnwrappedAddress],
+    accept_addrs: list[tuple[str, int]],
     forkserver_info: tuple[Any, Any, Any, Any, Any],
     start_method: SpawnMethodKey,
-    parent_addr: UnwrappedAddress | None = None,
+    parent_addr: tuple[str, int] | None = None,
     infect_asyncio: bool = False,
 
 ) -> None:
@@ -207,7 +206,7 @@ def nest_from_op(
 def _trio_main(
     actor: Actor,
     *,
-    parent_addr: UnwrappedAddress|None = None,
+    parent_addr: tuple[str, int] | None = None,
     infect_asyncio: bool = False,
 
 ) -> None:

tractor/_exceptions.py

@@ -23,6 +23,7 @@ import builtins
 import importlib
 from pprint import pformat
 from pdb import bdb
+import sys
 from types import (
     TracebackType,
 )
@@ -71,22 +72,8 @@ log = get_logger('tractor')
 _this_mod = importlib.import_module(__name__)
 
 
-class RuntimeFailure(RuntimeError):
+class ActorFailure(Exception):
-    '''
+    "General actor failure"
-    General `Actor`-runtime failure due to,
-
-    - a bad runtime-env,
-    - falied spawning (bad input to process),
-    -   API usage.
-
-    '''
-
-
-class ActorFailure(RuntimeFailure):
-    '''
-    `Actor` failed to boot before/after spawn
-
-    '''
 
 
 class InternalError(RuntimeError):
@@ -139,12 +126,6 @@ class TrioTaskExited(Exception):
     '''
 
 
-class DebugRequestError(RuntimeError):
-    '''
-    Failed to request stdio lock from root actor!
-
-    '''
-
 # NOTE: more or less should be close to these:
 # 'boxed_type',
 # 'src_type',
@@ -210,8 +191,6 @@ def get_err_type(type_name: str) -> BaseException|None:
         ):
             return type_ref
 
-    return None
-
 
 def pack_from_raise(
     local_err: (
@@ -542,6 +521,7 @@ class RemoteActorError(Exception):
             if val:
                 _repr += f'{key}={val_str}{end_char}'
 
+
         return _repr
 
     def reprol(self) -> str:
@@ -620,9 +600,56 @@ class RemoteActorError(Exception):
             the type name is already implicitly shown by python).
 
         '''
+        header: str = ''
+        body: str = ''
+        message: str = ''
+
+        # XXX when the currently raised exception is this instance,
+        # we do not ever use the "type header" style repr.
+        is_being_raised: bool = False
+        if (
+            (exc := sys.exception())
+            and
+            exc is self
+        ):
+            is_being_raised: bool = True
+
+        with_type_header: bool = (
+            with_type_header
+            and
+            not is_being_raised
+        )
+
+        # <RemoteActorError( .. )> style
+        if with_type_header:
+            header: str = f'<{type(self).__name__}('
+
+        if message := self._message:
+
+            # split off the first line so, if needed, it isn't
+            # indented the same like the "boxed content" which
+            # since there is no `.tb_str` is just the `.message`.
+            lines: list[str] = message.splitlines()
+            first: str = lines[0]
+            message: str = message.removeprefix(first)
+
+            # with a type-style header we,
+            # - have no special message "first line" extraction/handling
+            # - place the message a space in from the header:
+            #  `MsgTypeError( <message> ..`
+            #                 ^-here
+            # - indent the `.message` inside the type body.
+            if with_type_header:
+                first = f' {first} )>'
+
+            message: str = textwrap.indent(
+                message,
+                prefix=' '*2,
+            )
+            message: str = first + message
+
         # IFF there is an embedded traceback-str we always
         # draw the ascii-box around it.
-        body: str = ''
         if tb_str := self.tb_str:
             fields: str = self._mk_fields_str(
                 _body_fields
@@ -643,15 +670,21 @@ class RemoteActorError(Exception):
                 boxer_header=self.relay_uid,
             )
 
-        # !TODO, it'd be nice to import these top level without
+        tail = ''
-        # cycles!
+        if (
-        from tractor.devx.pformat import (
+            with_type_header
-            pformat_exc,
+            and not message
-        )
+        ):
-        return pformat_exc(
+            tail: str = '>'
-            exc=self,
+
-            with_type_header=with_type_header,
+        return (
-            body=body,
+            header
+            +
+            message
+            +
+            f'{body}'
+            +
+            tail
         )
 
     __repr__ = pformat
@@ -929,7 +962,7 @@ class StreamOverrun(
     '''
 
 
-class TransportClosed(Exception):
+class TransportClosed(trio.BrokenResourceError):
     '''
     IPC transport (protocol) connection was closed or broke and
     indicates that the wrapping communication `Channel` can no longer
@@ -940,39 +973,24 @@ class TransportClosed(Exception):
         self,
         message: str,
         loglevel: str = 'transport',
-        src_exc: Exception|None = None,
+        cause: BaseException|None = None,
         raise_on_report: bool = False,
 
     ) -> None:
         self.message: str = message
-        self._loglevel: str = loglevel
+        self._loglevel = loglevel
         super().__init__(message)
 
-        self._src_exc = src_exc
+        if cause is not None:
-        # set the cause manually if not already set by python
+            self.__cause__ = cause
-        if (
-            src_exc is not None
-            and
-            not self.__cause__
-        ):
-            self.__cause__ = src_exc
 
         # flag to toggle whether the msg loop should raise
         # the exc in its `TransportClosed` handler block.
         self._raise_on_report = raise_on_report
 
-    @property
-    def src_exc(self) -> Exception:
-        return (
-            self.__cause__
-            or
-            self._src_exc
-        )
-
     def report_n_maybe_raise(
         self,
         message: str|None = None,
-        hide_tb: bool = True,
 
     ) -> None:
         '''
@@ -980,10 +998,9 @@ class TransportClosed(Exception):
         for this error.
 
         '''
-        __tracebackhide__: bool = hide_tb
         message: str = message or self.message
         # when a cause is set, slap it onto the log emission.
-        if cause := self.src_exc:
+        if cause := self.__cause__:
             cause_tb_str: str = ''.join(
                 traceback.format_tb(cause.__traceback__)
             )
@@ -992,86 +1009,13 @@ class TransportClosed(Exception):
                 f'    {cause}\n'  # exc repr
             )
 
-        getattr(
+        getattr(log, self._loglevel)(message)
-            log,
-            self._loglevel
-        )(message)
 
         # some errors we want to blow up from
         # inside the RPC msg loop
         if self._raise_on_report:
             raise self from cause
 
-    @classmethod
-    def repr_src_exc(
-        self,
-        src_exc: Exception|None = None,
-    ) -> str:
-
-        if src_exc is None:
-            return '<unknown>'
-
-        src_msg: tuple[str] = src_exc.args
-        src_exc_repr: str = (
-            f'{type(src_exc).__name__}[ {src_msg} ]'
-        )
-        return src_exc_repr
-
-    def pformat(self) -> str:
-        from tractor.devx.pformat import (
-            pformat_exc,
-        )
-        return pformat_exc(
-            exc=self,
-        )
-
-    # delegate to `str`-ified pformat
-    __repr__ = pformat
-
-    @classmethod
-    def from_src_exc(
-        cls,
-        src_exc: (
-            Exception|
-            trio.ClosedResource|
-            trio.BrokenResourceError
-        ),
-        message: str,
-        body: str = '',
-        **init_kws,
-    ) -> TransportClosed:
-        '''
-        Convenience constructor for creation from an underlying
-        `trio`-sourced async-resource/chan/stream error.
-
-        Embeds the original `src_exc`'s repr within the
-        `Exception.args` via a first-line-in-`.message`-put-in-header
-        pre-processing and allows inserting additional content beyond
-        the main message via a `body: str`.
-
-        '''
-        repr_src_exc: str = cls.repr_src_exc(
-            src_exc,
-        )
-        next_line: str = f'  src_exc: {repr_src_exc}\n'
-        if body:
-            body: str = textwrap.indent(
-                body,
-                prefix=' '*2,
-            )
-
-        return TransportClosed(
-            message=(
-                message
-                +
-                next_line
-                +
-                body
-            ),
-            src_exc=src_exc,
-            **init_kws,
-        )
-
 
 class NoResult(RuntimeError):
     "No final result is expected for this actor"

tractor/_portal.py

@@ -52,8 +52,8 @@ from .msg import (
     Return,
 )
 from ._exceptions import (
+    # unpack_error,
     NoResult,
-    TransportClosed,
 )
 from ._context import (
     Context,
@@ -107,10 +107,6 @@ class Portal:
         # point.
         self._expect_result_ctx: Context|None = None
         self._streams: set[MsgStream] = set()
-
-        # TODO, this should be PRIVATE (and never used publicly)! since it's just
-        # a cached ref to the local runtime instead of calling
-        # `current_actor()` everywhere.. XD
         self.actor: Actor = current_actor()
 
     @property
@@ -175,7 +171,7 @@ class Portal:
         # not expecting a "main" result
         if self._expect_result_ctx is None:
             log.warning(
-                f"Portal for {self.channel.aid} not expecting a final"
+                f"Portal for {self.channel.uid} not expecting a final"
                 " result?\nresult() should only be called if subactor"
                 " was spawned with `ActorNursery.run_in_actor()`")
             return NoResult
@@ -222,7 +218,7 @@ class Portal:
         # IPC calls
         if self._streams:
             log.cancel(
-                f"Cancelling all streams with {self.channel.aid}")
+                f"Cancelling all streams with {self.channel.uid}")
             for stream in self._streams.copy():
                 try:
                     await stream.aclose()
@@ -267,7 +263,7 @@ class Portal:
             return False
 
         reminfo: str = (
-            f'c)=> {self.channel.aid}\n'
+            f'c)=> {self.channel.uid}\n'
             f'  |_{chan}\n'
         )
         log.cancel(
@@ -305,34 +301,14 @@ class Portal:
             return False
 
         except (
-            # XXX, should never really get raised unless we aren't
-            # wrapping them in the below type by mistake?
-            #
-            # Leaving the catch here for now until we're very sure
-            # all the cases (for various tpt protos) have indeed been
-            # re-wrapped ;p
             trio.ClosedResourceError,
             trio.BrokenResourceError,
-
+        ):
-            TransportClosed,
+            log.debug(
-        ) as tpt_err:
+                'IPC chan for actor already closed or broken?\n\n'
-            report: str = (
+                f'{self.channel.uid}\n'
-                f'IPC chan for actor already closed or broken?\n\n'
-                f'{self.channel.aid}\n'
                 f' |_{self.channel}\n'
             )
-            match tpt_err:
-                case TransportClosed():
-                    log.debug(report)
-                case _:
-                    report += (
-                        f'\n'
-                        f'Unhandled low-level transport-closed/error during\n'
-                        f'Portal.cancel_actor()` request?\n'
-                        f'<{type(tpt_err).__name__}( {tpt_err} )>\n'
-                    )
-                    log.warning(report)
-
             return False
 
     # TODO: do we still need this for low level `Actor`-runtime
@@ -528,12 +504,8 @@ class LocalPortal:
         return it's result.
 
         '''
-        obj = (
+        obj = self.actor if ns == 'self' else importlib.import_module(ns)
-            self.actor
+        func = getattr(obj, func_name)
-            if ns == 'self'
-            else importlib.import_module(ns)
-        )
-        func: Callable = getattr(obj, func_name)
         return await func(**kwargs)
 
 
@@ -571,17 +543,15 @@ async def open_portal(
             await channel.connect()
             was_connected = True
 
-        if channel.aid is None:
+        if channel.uid is None:
-            await channel._do_handshake(
+            await actor._do_handshake(channel)
-                aid=actor.aid,
-            )
 
         msg_loop_cs: trio.CancelScope|None = None
         if start_msg_loop:
-            from . import _rpc
+            from ._runtime import process_messages
             msg_loop_cs = await tn.start(
                 partial(
-                    _rpc.process_messages,
+                    process_messages,
                     actor,
                     channel,
                     # if the local task is cancelled we want to keep

tractor/_root.py

@@ -18,9 +18,7 @@
 Root actor runtime ignition(s).
 
 '''
-from contextlib import (
+from contextlib import asynccontextmanager as acm
-    asynccontextmanager as acm,
-)
 from functools import partial
 import importlib
 import inspect
@@ -28,10 +26,7 @@ import logging
 import os
 import signal
 import sys
-from typing import (
+from typing import Callable
-    Any,
-    Callable,
-)
 import warnings
 
 
@@ -48,111 +43,33 @@ from .devx import _debug
 from . import _spawn
 from . import _state
 from . import log
-from .ipc import (
+from .ipc import _connect_chan
-    _connect_chan,
+from ._exceptions import is_multi_cancelled
-)
+
-from ._addr import (
+
-    Address,
+# set at startup and after forks
-    UnwrappedAddress,
+_default_host: str = '127.0.0.1'
-    default_lo_addrs,
+_default_port: int = 1616
-    mk_uuid,
+
-    wrap_address,
+# default registry always on localhost
-)
+_default_lo_addrs: list[tuple[str, int]] = [(
-from ._exceptions import (
+    _default_host,
-    RuntimeFailure,
+    _default_port,
-    is_multi_cancelled,
+)]
-)
 
 
 logger = log.get_logger('tractor')
 
 
-# TODO: stick this in a `@acm` defined in `devx._debug`?
-# -[ ] also maybe consider making this a `wrapt`-deco to
-#     save an indent level?
-#
-@acm
-async def maybe_block_bp(
-    debug_mode: bool,
-    maybe_enable_greenback: bool,
-) -> bool:
-    # Override the global debugger hook to make it play nice with
-    # ``trio``, see much discussion in:
-    # https://github.com/python-trio/trio/issues/1155#issuecomment-742964018
-    builtin_bp_handler: Callable = sys.breakpointhook
-    orig_bp_path: str|None = os.environ.get(
-        'PYTHONBREAKPOINT',
-        None,
-    )
-    bp_blocked: bool
-    if (
-        debug_mode
-        and maybe_enable_greenback
-        and (
-            maybe_mod := await _debug.maybe_init_greenback(
-                raise_not_found=False,
-            )
-        )
-    ):
-        logger.info(
-            f'Found `greenback` installed @ {maybe_mod}\n'
-            'Enabling `tractor.pause_from_sync()` support!\n'
-        )
-        os.environ['PYTHONBREAKPOINT'] = (
-            'tractor.devx._debug._sync_pause_from_builtin'
-        )
-        _state._runtime_vars['use_greenback'] = True
-        bp_blocked = False
-
-    else:
-        # TODO: disable `breakpoint()` by default (without
-        # `greenback`) since it will break any multi-actor
-        # usage by a clobbered TTY's stdstreams!
-        def block_bps(*args, **kwargs):
-            raise RuntimeError(
-                'Trying to use `breakpoint()` eh?\n\n'
-                'Welp, `tractor` blocks `breakpoint()` built-in calls by default!\n'
-                'If you need to use it please install `greenback` and set '
-                '`debug_mode=True` when opening the runtime '
-                '(either via `.open_nursery()` or `open_root_actor()`)\n'
-            )
-
-        sys.breakpointhook = block_bps
-        # lol ok,
-        # https://docs.python.org/3/library/sys.html#sys.breakpointhook
-        os.environ['PYTHONBREAKPOINT'] = "0"
-        bp_blocked = True
-
-    try:
-        yield bp_blocked
-    finally:
-        # restore any prior built-in `breakpoint()` hook state
-        if builtin_bp_handler is not None:
-            sys.breakpointhook = builtin_bp_handler
-
-        if orig_bp_path is not None:
-            os.environ['PYTHONBREAKPOINT'] = orig_bp_path
-
-        else:
-            # clear env back to having no entry
-            os.environ.pop('PYTHONBREAKPOINT', None)
-
-
-
 @acm
 async def open_root_actor(
+
     *,
     # defaults are above
-    registry_addrs: list[UnwrappedAddress]|None = None,
+    registry_addrs: list[tuple[str, int]]|None = None,
 
     # defaults are above
-    arbiter_addr: tuple[UnwrappedAddress]|None = None,
+    arbiter_addr: tuple[str, int]|None = None,
-
-    enable_transports: list[
-        # TODO, this should eventually be the pairs as
-        # defined by (codec, proto) as on `MsgTransport.
-        _state.TransportProtocolKey,
-    ]|None = None,
 
     name: str|None = 'root',
 
@@ -194,331 +111,350 @@ async def open_root_actor(
     Runtime init entry point for ``tractor``.
 
     '''
-    # XXX NEVER allow nested actor-trees!
+    _debug.hide_runtime_frames()
-    if already_actor := _state.current_actor(err_on_no_runtime=False):
+    __tracebackhide__: bool = hide_tb
-        rtvs: dict[str, Any] = _state._runtime_vars
-        root_mailbox: list[str, int] = rtvs['_root_mailbox']
-        registry_addrs: list[list[str, int]] = rtvs['_registry_addrs']
-        raise RuntimeFailure(
-            f'A current actor already exists !?\n'
-            f'({already_actor}\n'
-            f'\n'
-            f'You can NOT open a second root actor from within '
-            f'an existing tree and the current root of this '
-            f'already exists !!\n'
-            f'\n'
-            f'_root_mailbox: {root_mailbox!r}\n'
-            f'_registry_addrs: {registry_addrs!r}\n'
-        )
 
-    async with maybe_block_bp(
+    # TODO: stick this in a `@cm` defined in `devx._debug`?
-        debug_mode=debug_mode,
+    #
-        maybe_enable_greenback=maybe_enable_greenback,
+    # Override the global debugger hook to make it play nice with
+    # ``trio``, see much discussion in:
+    # https://github.com/python-trio/trio/issues/1155#issuecomment-742964018
+    builtin_bp_handler: Callable = sys.breakpointhook
+    orig_bp_path: str|None = os.environ.get(
+        'PYTHONBREAKPOINT',
+        None,
+    )
+    if (
+        debug_mode
+        and maybe_enable_greenback
+        and (
+            maybe_mod := await _debug.maybe_init_greenback(
+                raise_not_found=False,
+            )
+        )
     ):
-        if enable_transports is None:
+        logger.info(
-            enable_transports: list[str] = _state.current_ipc_protos()
+            f'Found `greenback` installed @ {maybe_mod}\n'
+            'Enabling `tractor.pause_from_sync()` support!\n'
+        )
+        os.environ['PYTHONBREAKPOINT'] = (
+            'tractor.devx._debug._sync_pause_from_builtin'
+        )
+        _state._runtime_vars['use_greenback'] = True
 
-            # TODO! support multi-tpts per actor! Bo
+    else:
-            assert (
+        # TODO: disable `breakpoint()` by default (without
-                len(enable_transports) == 1
+        # `greenback`) since it will break any multi-actor
-            ), 'No multi-tpt support yet!'
+        # usage by a clobbered TTY's stdstreams!
+        def block_bps(*args, **kwargs):
+            raise RuntimeError(
+                'Trying to use `breakpoint()` eh?\n\n'
+                'Welp, `tractor` blocks `breakpoint()` built-in calls by default!\n'
+                'If you need to use it please install `greenback` and set '
+                '`debug_mode=True` when opening the runtime '
+                '(either via `.open_nursery()` or `open_root_actor()`)\n'
+            )
 
-        _debug.hide_runtime_frames()
+        sys.breakpointhook = block_bps
-        __tracebackhide__: bool = hide_tb
+        # lol ok,
+        # https://docs.python.org/3/library/sys.html#sys.breakpointhook
+        os.environ['PYTHONBREAKPOINT'] = "0"
 
-        # attempt to retreive ``trio``'s sigint handler and stash it
+    # attempt to retreive ``trio``'s sigint handler and stash it
-        # on our debugger lock state.
+    # on our debugger lock state.
-        _debug.DebugStatus._trio_handler = signal.getsignal(signal.SIGINT)
+    _debug.DebugStatus._trio_handler = signal.getsignal(signal.SIGINT)
 
-        # mark top most level process as root actor
+    # mark top most level process as root actor
-        _state._runtime_vars['_is_root'] = True
+    _state._runtime_vars['_is_root'] = True
 
-        # caps based rpc list
+    # caps based rpc list
-        enable_modules = (
+    enable_modules = (
-            enable_modules
+        enable_modules
-            or
+        or
-            []
+        []
+    )
+
+    if rpc_module_paths:
+        warnings.warn(
+            "`rpc_module_paths` is now deprecated, use "
+            " `enable_modules` instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        enable_modules.extend(rpc_module_paths)
+
+    if start_method is not None:
+        _spawn.try_set_start_method(start_method)
+
+    if arbiter_addr is not None:
+        warnings.warn(
+            '`arbiter_addr` is now deprecated\n'
+            'Use `registry_addrs: list[tuple]` instead..',
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        registry_addrs = [arbiter_addr]
+
+    registry_addrs: list[tuple[str, int]] = (
+        registry_addrs
+        or
+        _default_lo_addrs
+    )
+    assert registry_addrs
+
+    loglevel = (
+        loglevel
+        or log._default_loglevel
+    ).upper()
+
+    if (
+        debug_mode
+        and _spawn._spawn_method == 'trio'
+    ):
+        _state._runtime_vars['_debug_mode'] = True
+
+        # expose internal debug module to every actor allowing for
+        # use of ``await tractor.pause()``
+        enable_modules.append('tractor.devx._debug')
+
+        # if debug mode get's enabled *at least* use that level of
+        # logging for some informative console prompts.
+        if (
+            logging.getLevelName(
+                # lul, need the upper case for the -> int map?
+                # sweet "dynamic function behaviour" stdlib...
+                loglevel,
+            ) > logging.getLevelName('PDB')
+        ):
+            loglevel = 'PDB'
+
+
+    elif debug_mode:
+        raise RuntimeError(
+            "Debug mode is only supported for the `trio` backend!"
         )
 
-        if rpc_module_paths:
+    assert loglevel
-            warnings.warn(
+    _log = log.get_console_log(loglevel)
-                "`rpc_module_paths` is now deprecated, use "
+    assert _log
-                " `enable_modules` instead.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-            enable_modules.extend(rpc_module_paths)
 
-        if start_method is not None:
+    # TODO: factor this into `.devx._stackscope`!!
-            _spawn.try_set_start_method(start_method)
+    if (
+        debug_mode
+        and
+        enable_stack_on_sig
+    ):
+        from .devx._stackscope import enable_stack_on_sig
+        enable_stack_on_sig()
 
-        # TODO! remove this ASAP!
+    # closed into below ping task-func
-        if arbiter_addr is not None:
+    ponged_addrs: list[tuple[str, int]] = []
-            warnings.warn(
-                '`arbiter_addr` is now deprecated\n'
-                'Use `registry_addrs: list[tuple]` instead..',
-                DeprecationWarning,
-                stacklevel=2,
-            )
-            registry_addrs = [arbiter_addr]
 
-        if not registry_addrs:
+    async def ping_tpt_socket(
-            registry_addrs: list[UnwrappedAddress] = default_lo_addrs(
+        addr: tuple[str, int],
-                enable_transports
+        timeout: float = 1,
+    ) -> None:
+        '''
+        Attempt temporary connection to see if a registry is
+        listening at the requested address by a tranport layer
+        ping.
+
+        If a connection can't be made quickly we assume none no
+        server is listening at that addr.
+
+        '''
+        try:
+            # TODO: this connect-and-bail forces us to have to
+            # carefully rewrap TCP 104-connection-reset errors as
+            # EOF so as to avoid propagating cancel-causing errors
+            # to the channel-msg loop machinery. Likely it would
+            # be better to eventually have a "discovery" protocol
+            # with basic handshake instead?
+            with trio.move_on_after(timeout):
+                async with _connect_chan(*addr):
+                    ponged_addrs.append(addr)
+
+        except OSError:
+            # TODO: make this a "discovery" log level?
+            logger.info(
+                f'No actor registry found @ {addr}\n'
             )
 
-        assert registry_addrs
+    async with trio.open_nursery() as tn:
+        for addr in registry_addrs:
+            tn.start_soon(
+                ping_tpt_socket,
+                tuple(addr),  # TODO: just drop this requirement?
+            )
 
-        loglevel = (
+    trans_bind_addrs: list[tuple[str, int]] = []
-            loglevel
-            or log._default_loglevel
-        ).upper()
 
-        if (
+    # Create a new local root-actor instance which IS NOT THE
-            debug_mode
+    # REGISTRAR
-            and _spawn._spawn_method == 'trio'
+    if ponged_addrs:
-        ):
+        if ensure_registry:
-            _state._runtime_vars['_debug_mode'] = True
-
-            # expose internal debug module to every actor allowing for
-            # use of ``await tractor.pause()``
-            enable_modules.append('tractor.devx._debug')
-
-            # if debug mode get's enabled *at least* use that level of
-            # logging for some informative console prompts.
-            if (
-                logging.getLevelName(
-                    # lul, need the upper case for the -> int map?
-                    # sweet "dynamic function behaviour" stdlib...
-                    loglevel,
-                ) > logging.getLevelName('PDB')
-            ):
-                loglevel = 'PDB'
-
-
-        elif debug_mode:
             raise RuntimeError(
-                "Debug mode is only supported for the `trio` backend!"
+                 f'Failed to open `{name}`@{ponged_addrs}: '
+                'registry socket(s) already bound'
             )
 
-        assert loglevel
+        # we were able to connect to an arbiter
-        _log = log.get_console_log(loglevel)
+        logger.info(
-        assert _log
+            f'Registry(s) seem(s) to exist @ {ponged_addrs}'
+        )
 
-        # TODO: factor this into `.devx._stackscope`!!
+        actor = Actor(
+            name=name or 'anonymous',
+            registry_addrs=ponged_addrs,
+            loglevel=loglevel,
+            enable_modules=enable_modules,
+        )
+        # DO NOT use the registry_addrs as the transport server
+        # addrs for this new non-registar, root-actor.
+        for host, port in ponged_addrs:
+            # NOTE: zero triggers dynamic OS port allocation
+            trans_bind_addrs.append((host, 0))
+
+    # Start this local actor as the "registrar", aka a regular
+    # actor who manages the local registry of "mailboxes" of
+    # other process-tree-local sub-actors.
+    else:
+
+        # NOTE that if the current actor IS THE REGISTAR, the
+        # following init steps are taken:
+        # - the tranport layer server is bound to each (host, port)
+        #   pair defined in provided registry_addrs, or the default.
+        trans_bind_addrs = registry_addrs
+
+        # - it is normally desirable for any registrar to stay up
+        #   indefinitely until either all registered (child/sub)
+        #   actors are terminated (via SC supervision) or,
+        #   a re-election process has taken place. 
+        # NOTE: all of ^ which is not implemented yet - see:
+        # https://github.com/goodboy/tractor/issues/216
+        # https://github.com/goodboy/tractor/pull/348
+        # https://github.com/goodboy/tractor/issues/296
+
+        actor = Arbiter(
+            name or 'registrar',
+            registry_addrs=registry_addrs,
+            loglevel=loglevel,
+            enable_modules=enable_modules,
+        )
+        # XXX, in case the root actor runtime was actually run from
+        # `tractor.to_asyncio.run_as_asyncio_guest()` and NOt
+        # `.trio.run()`.
+        actor._infected_aio = _state._runtime_vars['_is_infected_aio']
+
+    # Start up main task set via core actor-runtime nurseries.
+    try:
+        # assign process-local actor
+        _state._current_actor = actor
+
+        # start local channel-server and fake the portal API
+        # NOTE: this won't block since we provide the nursery
+        ml_addrs_str: str = '\n'.join(
+            f'@{addr}' for addr in trans_bind_addrs
+        )
+        logger.info(
+            f'Starting local {actor.uid} on the following transport addrs:\n'
+            f'{ml_addrs_str}'
+        )
+
+        # start the actor runtime in a new task
+        async with trio.open_nursery(
+            strict_exception_groups=False,
+            # ^XXX^ TODO? instead unpack any RAE as per "loose" style?
+        ) as nursery:
+
+            # ``_runtime.async_main()`` creates an internal nursery
+            # and blocks here until any underlying actor(-process)
+            # tree has terminated thereby conducting so called
+            # "end-to-end" structured concurrency throughout an
+            # entire hierarchical python sub-process set; all
+            # "actor runtime" primitives are SC-compat and thus all
+            # transitively spawned actors/processes must be as
+            # well.
+            await nursery.start(
+                partial(
+                    async_main,
+                    actor,
+                    accept_addrs=trans_bind_addrs,
+                    parent_addr=None
+                )
+            )
+            try:
+                yield actor
+            except (
+                Exception,
+                BaseExceptionGroup,
+            ) as err:
+
+                # TODO, in beginning to handle the subsubactor with
+                # crashed grandparent cases..
+                #
+                # was_locked: bool = await _debug.maybe_wait_for_debugger(
+                #     child_in_debug=True,
+                # )
+                # XXX NOTE XXX see equiv note inside
+                # `._runtime.Actor._stream_handler()` where in the
+                # non-root or root-that-opened-this-mahually case we
+                # wait for the local actor-nursery to exit before
+                # exiting the transport channel handler.
+                entered: bool = await _debug._maybe_enter_pm(
+                    err,
+                    api_frame=inspect.currentframe(),
+                    debug_filter=debug_filter,
+                )
+
+                if (
+                    not entered
+                    and
+                    not is_multi_cancelled(
+                        err,
+                    )
+                ):
+                    logger.exception('Root actor crashed\n')
+
+                # ALWAYS re-raise any error bubbled up from the
+                # runtime!
+                raise
+
+            finally:
+                # NOTE: not sure if we'll ever need this but it's
+                # possibly better for even more determinism?
+                # logger.cancel(
+                #     f'Waiting on {len(nurseries)} nurseries in root..')
+                # nurseries = actor._actoruid2nursery.values()
+                # async with trio.open_nursery() as tempn:
+                #     for an in nurseries:
+                #         tempn.start_soon(an.exited.wait)
+
+                logger.info(
+                    'Closing down root actor'
+                )
+                await actor.cancel(None)  # self cancel
+    finally:
+        _state._current_actor = None
+        _state._last_actor_terminated = actor
+
+        # restore built-in `breakpoint()` hook state
         if (
             debug_mode
             and
-            enable_stack_on_sig
+            maybe_enable_greenback
         ):
-            from .devx._stackscope import enable_stack_on_sig
+            if builtin_bp_handler is not None:
-            enable_stack_on_sig()
+                sys.breakpointhook = builtin_bp_handler
 
-        # closed into below ping task-func
+            if orig_bp_path is not None:
-        ponged_addrs: list[UnwrappedAddress] = []
+                os.environ['PYTHONBREAKPOINT'] = orig_bp_path
 
-        async def ping_tpt_socket(
+            else:
-            addr: UnwrappedAddress,
+                # clear env back to having no entry
-            timeout: float = 1,
+                os.environ.pop('PYTHONBREAKPOINT', None)
-        ) -> None:
-            '''
-            Attempt temporary connection to see if a registry is
-            listening at the requested address by a tranport layer
-            ping.
 
-            If a connection can't be made quickly we assume none no
+        logger.runtime("Root actor terminated")
-            server is listening at that addr.
-
-            '''
-            try:
-                # TODO: this connect-and-bail forces us to have to
-                # carefully rewrap TCP 104-connection-reset errors as
-                # EOF so as to avoid propagating cancel-causing errors
-                # to the channel-msg loop machinery. Likely it would
-                # be better to eventually have a "discovery" protocol
-                # with basic handshake instead?
-                with trio.move_on_after(timeout):
-                    async with _connect_chan(addr):
-                        ponged_addrs.append(addr)
-
-            except OSError:
-                # TODO: make this a "discovery" log level?
-                logger.info(
-                    f'No actor registry found @ {addr}\n'
-                )
-
-        async with trio.open_nursery() as tn:
-            for addr in registry_addrs:
-                tn.start_soon(
-                    ping_tpt_socket,
-                    addr,
-                )
-
-        trans_bind_addrs: list[UnwrappedAddress] = []
-
-        # Create a new local root-actor instance which IS NOT THE
-        # REGISTRAR
-        if ponged_addrs:
-            if ensure_registry:
-                raise RuntimeError(
-                     f'Failed to open `{name}`@{ponged_addrs}: '
-                    'registry socket(s) already bound'
-                )
-
-            # we were able to connect to an arbiter
-            logger.info(
-                f'Registry(s) seem(s) to exist @ {ponged_addrs}'
-            )
-
-            actor = Actor(
-                name=name or 'anonymous',
-                uuid=mk_uuid(),
-                registry_addrs=ponged_addrs,
-                loglevel=loglevel,
-                enable_modules=enable_modules,
-            )
-            # DO NOT use the registry_addrs as the transport server
-            # addrs for this new non-registar, root-actor.
-            for addr in ponged_addrs:
-                waddr: Address = wrap_address(addr)
-                trans_bind_addrs.append(
-                    waddr.get_random(bindspace=waddr.bindspace)
-                )
-
-        # Start this local actor as the "registrar", aka a regular
-        # actor who manages the local registry of "mailboxes" of
-        # other process-tree-local sub-actors.
-        else:
-
-            # NOTE that if the current actor IS THE REGISTAR, the
-            # following init steps are taken:
-            # - the tranport layer server is bound to each addr
-            #   pair defined in provided registry_addrs, or the default.
-            trans_bind_addrs = registry_addrs
-
-            # - it is normally desirable for any registrar to stay up
-            #   indefinitely until either all registered (child/sub)
-            #   actors are terminated (via SC supervision) or,
-            #   a re-election process has taken place.
-            # NOTE: all of ^ which is not implemented yet - see:
-            # https://github.com/goodboy/tractor/issues/216
-            # https://github.com/goodboy/tractor/pull/348
-            # https://github.com/goodboy/tractor/issues/296
-
-            actor = Arbiter(
-                name=name or 'registrar',
-                uuid=mk_uuid(),
-                registry_addrs=registry_addrs,
-                loglevel=loglevel,
-                enable_modules=enable_modules,
-            )
-            # XXX, in case the root actor runtime was actually run from
-            # `tractor.to_asyncio.run_as_asyncio_guest()` and NOt
-            # `.trio.run()`.
-            actor._infected_aio = _state._runtime_vars['_is_infected_aio']
-
-        # Start up main task set via core actor-runtime nurseries.
-        try:
-            # assign process-local actor
-            _state._current_actor = actor
-
-            # start local channel-server and fake the portal API
-            # NOTE: this won't block since we provide the nursery
-            ml_addrs_str: str = '\n'.join(
-                f'@{addr}' for addr in trans_bind_addrs
-            )
-            logger.info(
-                f'Starting local {actor.uid} on the following transport addrs:\n'
-                f'{ml_addrs_str}'
-            )
-
-            # start the actor runtime in a new task
-            async with trio.open_nursery(
-                strict_exception_groups=False,
-                # ^XXX^ TODO? instead unpack any RAE as per "loose" style?
-            ) as nursery:
-
-                # ``_runtime.async_main()`` creates an internal nursery
-                # and blocks here until any underlying actor(-process)
-                # tree has terminated thereby conducting so called
-                # "end-to-end" structured concurrency throughout an
-                # entire hierarchical python sub-process set; all
-                # "actor runtime" primitives are SC-compat and thus all
-                # transitively spawned actors/processes must be as
-                # well.
-                await nursery.start(
-                    partial(
-                        async_main,
-                        actor,
-                        accept_addrs=trans_bind_addrs,
-                        parent_addr=None
-                    )
-                )
-                try:
-                    yield actor
-                except (
-                    Exception,
-                    BaseExceptionGroup,
-                ) as err:
-
-                    # TODO, in beginning to handle the subsubactor with
-                    # crashed grandparent cases..
-                    #
-                    # was_locked: bool = await _debug.maybe_wait_for_debugger(
-                    #     child_in_debug=True,
-                    # )
-                    # XXX NOTE XXX see equiv note inside
-                    # `._runtime.Actor._stream_handler()` where in the
-                    # non-root or root-that-opened-this-mahually case we
-                    # wait for the local actor-nursery to exit before
-                    # exiting the transport channel handler.
-                    entered: bool = await _debug._maybe_enter_pm(
-                        err,
-                        api_frame=inspect.currentframe(),
-                        debug_filter=debug_filter,
-                    )
-
-                    if (
-                        not entered
-                        and
-                        not is_multi_cancelled(
-                            err,
-                        )
-                    ):
-                        logger.exception(
-                            'Root actor crashed\n'
-                            f'>x)\n'
-                            f' |_{actor}\n'
-                        )
-
-                    # ALWAYS re-raise any error bubbled up from the
-                    # runtime!
-                    raise
-
-                finally:
-                    # NOTE: not sure if we'll ever need this but it's
-                    # possibly better for even more determinism?
-                    # logger.cancel(
-                    #     f'Waiting on {len(nurseries)} nurseries in root..')
-                    # nurseries = actor._actoruid2nursery.values()
-                    # async with trio.open_nursery() as tempn:
-                    #     for an in nurseries:
-                    #         tempn.start_soon(an.exited.wait)
-
-                    logger.info(
-                        f'Closing down root actor\n'
-                        f'>)\n'
-                        f'|_{actor}\n'
-                    )
-                    await actor.cancel(None)  # self cancel
-        finally:
-            _state._current_actor = None
-            _state._last_actor_terminated = actor
-            logger.runtime(
-                f'Root actor terminated\n'
-                f')>\n'
-                f' |_{actor}\n'
-            )
 
 
 def run_daemon(
@@ -526,7 +462,7 @@ def run_daemon(
 
     # runtime kwargs
     name: str | None = 'root',
-    registry_addrs: list[UnwrappedAddress]|None = None,
+    registry_addrs: list[tuple[str, int]] = _default_lo_addrs,
 
     start_method: str | None = None,
     debug_mode: bool = False,

tractor/_rpc.py

@@ -1156,7 +1156,7 @@ async def process_messages(
                                 trio.Event(),
                             )
 
-                    # XXX RUNTIME-SCOPED! remote (likely internal) error
+                    # runtime-scoped remote (internal) error
                     # (^- bc no `Error.cid` -^)
                     #
                     # NOTE: this is the non-rpc error case, that
@@ -1219,10 +1219,8 @@ async def process_messages(
         # -[ ] figure out how this will break with other transports?
         tc.report_n_maybe_raise(
             message=(
-                f'peer IPC channel closed abruptly?\n'
+                f'peer IPC channel closed abruptly?\n\n'
-                f'\n'
+                f'<=x {chan}\n'
-                f'<=x[\n'
-                f'  {chan}\n'
                 f'  |_{chan.raddr}\n\n'
             )
             +

tractor/_spawn.py

@@ -46,23 +46,19 @@ from tractor._state import (
     _runtime_vars,
 )
 from tractor.log import get_logger
-from tractor._addr import UnwrappedAddress
 from tractor._portal import Portal
 from tractor._runtime import Actor
 from tractor._entry import _mp_main
 from tractor._exceptions import ActorFailure
 from tractor.msg.types import (
-    Aid,
     SpawnSpec,
 )
 
 
 if TYPE_CHECKING:
-    from ipc import IPCServer
     from ._supervise import ActorNursery
     ProcessType = TypeVar('ProcessType', mp.Process, trio.Process)
 
-
 log = get_logger('tractor')
 
 # placeholder for an mp start context if so using that backend
@@ -167,7 +163,7 @@ async def exhaust_portal(
         # TODO: merge with above?
         log.warning(
             'Cancelled portal result waiter task:\n'
-            f'uid: {portal.channel.aid}\n'
+            f'uid: {portal.channel.uid}\n'
             f'error: {err}\n'
         )
         return err
@@ -175,7 +171,7 @@ async def exhaust_portal(
     else:
         log.debug(
             f'Returning final result from portal:\n'
-            f'uid: {portal.channel.aid}\n'
+            f'uid: {portal.channel.uid}\n'
             f'result: {final}\n'
         )
         return final
@@ -328,12 +324,12 @@ async def soft_kill(
     see `.hard_kill()`).
 
     '''
-    peer_aid: Aid = portal.channel.aid
+    uid: tuple[str, str] = portal.channel.uid
     try:
         log.cancel(
             f'Soft killing sub-actor via portal request\n'
             f'\n'
-            f'(c=> {peer_aid}\n'
+            f'(c=> {portal.chan.uid}\n'
             f'  |_{proc}\n'
         )
         # wait on sub-proc to signal termination
@@ -382,7 +378,7 @@ async def soft_kill(
             if proc.poll() is None:  # type: ignore
                 log.warning(
                     'Subactor still alive after cancel request?\n\n'
-                    f'uid: {peer_aid}\n'
+                    f'uid: {uid}\n'
                     f'|_{proc}\n'
                 )
                 n.cancel_scope.cancel()
@@ -396,8 +392,8 @@ async def new_proc(
     errors: dict[tuple[str, str], Exception],
 
     # passed through to actor main
-    bind_addrs: list[UnwrappedAddress],
+    bind_addrs: list[tuple[str, int]],
-    parent_addr: UnwrappedAddress,
+    parent_addr: tuple[str, int],
     _runtime_vars: dict[str, Any],  # serialized and sent to _child
 
     *,
@@ -435,8 +431,8 @@ async def trio_proc(
     errors: dict[tuple[str, str], Exception],
 
     # passed through to actor main
-    bind_addrs: list[UnwrappedAddress],
+    bind_addrs: list[tuple[str, int]],
-    parent_addr: UnwrappedAddress,
+    parent_addr: tuple[str, int],
     _runtime_vars: dict[str, Any],  # serialized and sent to _child
     *,
     infect_asyncio: bool = False,
@@ -463,9 +459,6 @@ async def trio_proc(
         # the OS; it otherwise can be passed via the parent channel if
         # we prefer in the future (for privacy).
         "--uid",
-        # TODO, how to pass this over "wire" encodings like
-        # cmdline args?
-        # -[ ] maybe we can add an `Aid.min_tuple()` ?
         str(subactor.uid),
         # Address the child must connect to on startup
         "--parent_addr",
@@ -483,7 +476,6 @@ async def trio_proc(
 
     cancelled_during_spawn: bool = False
     proc: trio.Process|None = None
-    ipc_server: IPCServer = actor_nursery._actor.ipc_server
     try:
         try:
             proc: trio.Process = await trio.lowlevel.open_process(spawn_cmd, **proc_kwargs)
@@ -495,7 +487,7 @@ async def trio_proc(
             # wait for actor to spawn and connect back to us
             # channel should have handshake completed by the
             # local actor by the time we get a ref to it
-            event, chan = await ipc_server.wait_for_peer(
+            event, chan = await actor_nursery._actor.wait_for_peer(
                 subactor.uid
             )
 
@@ -528,15 +520,15 @@ async def trio_proc(
 
         # send a "spawning specification" which configures the
         # initial runtime state of the child.
-        sspec = SpawnSpec(
+        await chan.send(
-            _parent_main_data=subactor._parent_main_data,
+            SpawnSpec(
-            enable_modules=subactor.enable_modules,
+                _parent_main_data=subactor._parent_main_data,
-            reg_addrs=subactor.reg_addrs,
+                enable_modules=subactor.enable_modules,
-            bind_addrs=bind_addrs,
+                reg_addrs=subactor.reg_addrs,
-            _runtime_vars=_runtime_vars,
+                bind_addrs=bind_addrs,
+                _runtime_vars=_runtime_vars,
+            )
         )
-        log.runtime(f'Sending spawn spec: {str(sspec)}')
-        await chan.send(sspec)
 
         # track subactor in current nursery
         curr_actor: Actor = current_actor()
@@ -646,8 +638,8 @@ async def mp_proc(
     subactor: Actor,
     errors: dict[tuple[str, str], Exception],
     # passed through to actor main
-    bind_addrs: list[UnwrappedAddress],
+    bind_addrs: list[tuple[str, int]],
-    parent_addr: UnwrappedAddress,
+    parent_addr: tuple[str, int],
     _runtime_vars: dict[str, Any],  # serialized and sent to _child
     *,
     infect_asyncio: bool = False,
@@ -727,14 +719,12 @@ async def mp_proc(
 
     log.runtime(f"Started {proc}")
 
-    ipc_server: IPCServer = actor_nursery._actor.ipc_server
     try:
         # wait for actor to spawn and connect back to us
         # channel should have handshake completed by the
         # local actor by the time we get a ref to it
-        event, chan = await ipc_server.wait_for_peer(
+        event, chan = await actor_nursery._actor.wait_for_peer(
-            subactor.uid,
+            subactor.uid)
-        )
 
         # XXX: monkey patch poll API to match the ``subprocess`` API..
         # not sure why they don't expose this but kk.

tractor/_state.py

@@ -14,19 +14,16 @@
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-'''
+"""
-Per actor-process runtime state mgmt APIs.
+Per process state
 
-'''
+"""
 from __future__ import annotations
 from contextvars import (
     ContextVar,
 )
-import os
-from pathlib import Path
 from typing import (
     Any,
-    Literal,
     TYPE_CHECKING,
 )
 
@@ -102,7 +99,7 @@ def current_actor(
     return _current_actor
 
 
-def is_root_process() -> bool:
+def is_main_process() -> bool:
     '''
     Bool determining if this actor is running in the top-most process.
 
@@ -111,10 +108,8 @@ def is_root_process() -> bool:
     return mp.current_process().name == 'MainProcess'
 
 
-is_main_process = is_root_process
+# TODO, more verby name?
-
+def debug_mode() -> bool:
-
-def is_debug_mode() -> bool:
     '''
     Bool determining if "debug mode" is on which enables
     remote subactor pdb entry on crashes.
@@ -123,9 +118,6 @@ def is_debug_mode() -> bool:
     return bool(_runtime_vars['_debug_mode'])
 
 
-debug_mode = is_debug_mode
-
-
 def is_root_process() -> bool:
     return _runtime_vars['_is_root']
 
@@ -151,42 +143,3 @@ def current_ipc_ctx(
             f'|_{current_task()}\n'
         )
     return ctx
-
-
-# std ODE (mutable) app state location
-_rtdir: Path = Path(os.environ['XDG_RUNTIME_DIR'])
-
-
-def get_rt_dir(
-    subdir: str = 'tractor'
-) -> Path:
-    '''
-    Return the user "runtime dir" where most userspace apps stick
-    their IPC and cache related system util-files; we take hold
-    of a `'XDG_RUNTIME_DIR'/tractor/` subdir by default.
-
-    '''
-    rtdir: Path = _rtdir / subdir
-    if not rtdir.is_dir():
-        rtdir.mkdir()
-    return rtdir
-
-
-# default IPC transport protocol settings
-TransportProtocolKey = Literal[
-    'tcp',
-    'uds',
-]
-_def_tpt_proto: TransportProtocolKey = 'tcp'
-
-
-def current_ipc_protos() -> list[str]:
-    '''
-    Return the list of IPC transport protocol keys currently
-    in use by this actor.
-
-    The keys are as declared by `MsgTransport` and `Address`
-    concrete-backend sub-types defined throughout `tractor.ipc`.
-
-    '''
-    return [_def_tpt_proto]

tractor/_streaming.py

@@ -437,23 +437,22 @@ class MsgStream(trio.abc.Channel):
             message: str = (
                 f'Stream self-closed by {this_side!r}-side before EoC from {peer_side!r}\n'
                 # } bc a stream is a "scope"/msging-phase inside an IPC
-                f'c}}>\n'
+                f'x}}>\n'
                 f'  |_{self}\n'
             )
+            log.cancel(message)
+            self._eoc = trio.EndOfChannel(message)
+
             if (
                 (rx_chan := self._rx_chan)
                 and
                 (stats := rx_chan.statistics()).tasks_waiting_receive
             ):
-                message += (
+                log.cancel(
-                    f'AND there is still reader tasks,\n'
+                    f'Msg-stream is closing but there is still reader tasks,\n'
-                    f'\n'
                     f'{stats}\n'
                 )
 
-            log.cancel(message)
-            self._eoc = trio.EndOfChannel(message)
-
         # ?XXX WAIT, why do we not close the local mem chan `._rx_chan` XXX?
         # => NO, DEFINITELY NOT! <=
         # if we're a bi-dir `MsgStream` BECAUSE this same
@@ -596,17 +595,8 @@ class MsgStream(trio.abc.Channel):
             trio.ClosedResourceError,
             trio.BrokenResourceError,
             BrokenPipeError,
-        ) as _trans_err:
+        ) as trans_err:
-            trans_err = _trans_err
+            if hide_tb:
-            if (
-                hide_tb
-                and
-                self._ctx.chan._exc is trans_err
-                # ^XXX, IOW, only if the channel is marked errored
-                # for the same reason as whatever its underlying
-                # transport raised, do we keep the full low-level tb
-                # suppressed from the user.
-            ):
                 raise type(trans_err)(
                     *trans_err.args
                 ) from trans_err
@@ -812,12 +802,13 @@ async def open_stream_from_ctx(
                 # sanity, can remove?
                 assert eoc is stream._eoc
 
-                log.runtime(
+                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'
                 )
+
         finally:
             if ctx._portal:
                 try:

tractor/_supervise.py

@@ -22,20 +22,13 @@ from contextlib import asynccontextmanager as acm
 from functools import partial
 import inspect
 from pprint import pformat
-from typing import (
+from typing import TYPE_CHECKING
-    TYPE_CHECKING,
-)
 import typing
 import warnings
 
 import trio
 
-
 from .devx._debug import maybe_wait_for_debugger
-from ._addr import (
-    UnwrappedAddress,
-    mk_uuid,
-)
 from ._state import current_actor, is_main_process
 from .log import get_logger, get_loglevel
 from ._runtime import Actor
@@ -44,21 +37,18 @@ from ._exceptions import (
     is_multi_cancelled,
     ContextCancelled,
 )
-from ._root import (
+from ._root import open_root_actor
-    open_root_actor,
-)
 from . import _state
 from . import _spawn
 
 
 if TYPE_CHECKING:
     import multiprocessing as mp
-    # from .ipc._server import IPCServer
-    from .ipc import IPCServer
-
 
 log = get_logger(__name__)
 
+_default_bind_addr: tuple[str, int] = ('127.0.0.1', 0)
+
 
 class ActorNursery:
     '''
@@ -140,9 +130,8 @@ class ActorNursery:
 
         *,
 
-        bind_addrs: list[UnwrappedAddress]|None = None,
+        bind_addrs: list[tuple[str, int]] = [_default_bind_addr],
         rpc_module_paths: list[str]|None = None,
-        enable_transports: list[str] = [_state._def_tpt_proto],
         enable_modules: list[str]|None = None,
         loglevel: str|None = None,  # set log level per subactor
         debug_mode: bool|None = None,
@@ -189,9 +178,7 @@ class ActorNursery:
             enable_modules.extend(rpc_module_paths)
 
         subactor = Actor(
-            name=name,
+            name,
-            uuid=mk_uuid(),
-
             # modules allowed to invoked funcs from
             enable_modules=enable_modules,
             loglevel=loglevel,
@@ -199,7 +186,7 @@ class ActorNursery:
             # verbatim relay this actor's registrar addresses
             registry_addrs=current_actor().reg_addrs,
         )
-        parent_addr: UnwrappedAddress = self._actor.accept_addr
+        parent_addr = self._actor.accept_addr
         assert parent_addr
 
         # start a task to spawn a process
@@ -237,7 +224,7 @@ class ActorNursery:
         *,
 
         name: str | None = None,
-        bind_addrs: UnwrappedAddress|None = None,
+        bind_addrs: tuple[str, int] = [_default_bind_addr],
         rpc_module_paths: list[str] | None = None,
         enable_modules: list[str] | None = None,
         loglevel: str | None = None,  # set log level per subactor
@@ -318,13 +305,8 @@ class ActorNursery:
         children: dict = self._children
         child_count: int = len(children)
         msg: str = f'Cancelling actor nursery with {child_count} children\n'
-
-        server: IPCServer = self._actor.ipc_server
-
         with trio.move_on_after(3) as cs:
-            async with trio.open_nursery(
+            async with trio.open_nursery() as tn:
-                strict_exception_groups=False,
-            ) as tn:
 
                 subactor: Actor
                 proc: trio.Process
@@ -343,7 +325,7 @@ class ActorNursery:
 
                     else:
                         if portal is None:  # actor hasn't fully spawned yet
-                            event: trio.Event = server._peer_connected[subactor.uid]
+                            event = self._actor._peer_connected[subactor.uid]
                             log.warning(
                                 f"{subactor.uid} never 't finished spawning?"
                             )
@@ -359,7 +341,7 @@ class ActorNursery:
                             if portal is None:
                                 # cancelled while waiting on the event
                                 # to arrive
-                                chan = server._peers[subactor.uid][-1]
+                                chan = self._actor._peers[subactor.uid][-1]
                                 if chan:
                                     portal = Portal(chan)
                                 else:  # there's no other choice left

tractor/devx/_debug.py

@@ -73,7 +73,6 @@ from tractor.log import get_logger
 from tractor._context import Context
 from tractor import _state
 from tractor._exceptions import (
-    DebugRequestError,
     InternalError,
     NoRuntime,
     is_multi_cancelled,
@@ -92,11 +91,7 @@ from tractor._state import (
 if TYPE_CHECKING:
     from trio.lowlevel import Task
     from threading import Thread
-    from tractor.ipc import (
+    from tractor.ipc import Channel
-        Channel,
-        IPCServer,
-        # _server,  # TODO? export at top level?
-    )
     from tractor._runtime import (
         Actor,
     )
@@ -1438,7 +1433,6 @@ def any_connected_locker_child() -> bool:
 
     '''
     actor: Actor = current_actor()
-    server: IPCServer = actor.ipc_server
 
     if not is_root_process():
         raise InternalError('This is a root-actor only API!')
@@ -1448,7 +1442,7 @@ def any_connected_locker_child() -> bool:
         and
         (uid_in_debug := ctx.chan.uid)
     ):
-        chans: list[tractor.Channel] = server._peers.get(
+        chans: list[tractor.Channel] = actor._peers.get(
             tuple(uid_in_debug)
         )
         if chans:
@@ -1746,6 +1740,13 @@ def sigint_shield(
 _pause_msg: str = 'Opening a pdb REPL in paused actor'
 
 
+class DebugRequestError(RuntimeError):
+    '''
+    Failed to request stdio lock from root actor!
+
+    '''
+
+
 _repl_fail_msg: str|None = (
     'Failed to REPl via `_pause()` '
 )
@@ -3008,7 +3009,6 @@ async def _maybe_enter_pm(
         [BaseException|BaseExceptionGroup],
         bool,
     ] = lambda err: not is_multi_cancelled(err),
-    **_pause_kws,
 
 ):
     if (
@@ -3035,7 +3035,6 @@ async def _maybe_enter_pm(
         await post_mortem(
             api_frame=api_frame,
             tb=tb,
-            **_pause_kws,
         )
         return True
 

tractor/devx/pformat.py

@@ -19,7 +19,6 @@ Pretty formatters for use throughout the code base.
 Mostly handy for logging and exception message content.
 
 '''
-import sys
 import textwrap
 import traceback
 
@@ -116,85 +115,6 @@ def pformat_boxed_tb(
     )
 
 
-def pformat_exc(
-    exc: Exception,
-    header: str = '',
-    message: str = '',
-    body: str = '',
-    with_type_header: bool = True,
-) -> str:
-
-    # XXX when the currently raised exception is this instance,
-    # we do not ever use the "type header" style repr.
-    is_being_raised: bool = False
-    if (
-        (curr_exc := sys.exception())
-        and
-        curr_exc is exc
-    ):
-        is_being_raised: bool = True
-
-    with_type_header: bool = (
-        with_type_header
-        and
-        not is_being_raised
-    )
-
-    # <RemoteActorError( .. )> style
-    if (
-        with_type_header
-        and
-        not header
-    ):
-        header: str = f'<{type(exc).__name__}('
-
-    message: str = (
-        message
-        or
-        exc.message
-    )
-    if message:
-        # split off the first line so, if needed, it isn't
-        # indented the same like the "boxed content" which
-        # since there is no `.tb_str` is just the `.message`.
-        lines: list[str] = message.splitlines()
-        first: str = lines[0]
-        message: str = message.removeprefix(first)
-
-        # with a type-style header we,
-        # - have no special message "first line" extraction/handling
-        # - place the message a space in from the header:
-        #  `MsgTypeError( <message> ..`
-        #                 ^-here
-        # - indent the `.message` inside the type body.
-        if with_type_header:
-            first = f' {first} )>'
-
-        message: str = textwrap.indent(
-            message,
-            prefix=' '*2,
-        )
-        message: str = first + message
-
-    tail: str = ''
-    if (
-        with_type_header
-        and
-        not message
-    ):
-        tail: str = '>'
-
-    return (
-        header
-        +
-        message
-        +
-        f'{body}'
-        +
-        tail
-    )
-
-
 def pformat_caller_frame(
     stack_limit: int = 1,
     box_tb: bool = True,

tractor/experimental/_pubsub.py

@@ -45,8 +45,6 @@ __all__ = ['pub']
 log = get_logger('messaging')
 
 
-# TODO! this needs to reworked to use the modern
-# `Context`/`MsgStream` APIs!!
 async def fan_out_to_ctxs(
     pub_async_gen_func: typing.Callable,  # it's an async gen ... gd mypy
     topics2ctxs: dict[str, list],

tractor/ipc/__init__.py

@@ -13,11 +13,15 @@
 
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
-'''
+from ._transport import MsgTransport as MsgTransport
-A modular IPC layer supporting the power of cross-process SC!
+
+from ._tcp import (
+    get_stream_addrs as get_stream_addrs,
+    MsgpackTCPStream as MsgpackTCPStream
+)
 
-'''
 from ._chan import (
     _connect_chan as _connect_chan,
+    get_msg_transport as get_msg_transport,
     Channel as Channel
 )

tractor/ipc/_chan.py

@@ -29,35 +29,22 @@ from pprint import pformat
 import typing
 from typing import (
     Any,
-    TYPE_CHECKING,
+    Type
 )
-import warnings
 
 import trio
 
-from ._types import (
+from tractor.ipc._transport import MsgTransport
-    transport_from_addr,
+from tractor.ipc._tcp import (
-    transport_from_stream,
+    MsgpackTCPStream,
-)
+    get_stream_addrs
-from tractor._addr import (
-    is_wrapped_addr,
-    wrap_address,
-    Address,
-    UnwrappedAddress,
 )
 from tractor.log import get_logger
 from tractor._exceptions import (
     MsgTypeError,
     pack_from_raise,
-    TransportClosed,
 )
-from tractor.msg import (
+from tractor.msg import MsgCodec
-    Aid,
-    MsgCodec,
-)
-
-if TYPE_CHECKING:
-    from ._transport import MsgTransport
 
 
 log = get_logger(__name__)
@@ -65,6 +52,17 @@ log = get_logger(__name__)
 _is_windows = platform.system() == 'Windows'
 
 
+def get_msg_transport(
+
+    key: tuple[str, str],
+
+) -> Type[MsgTransport]:
+
+    return {
+        ('msgpack', 'tcp'): MsgpackTCPStream,
+    }[key]
+
+
 class Channel:
     '''
     An inter-process channel for communication between (remote) actors.
@@ -79,7 +77,10 @@ class Channel:
     def __init__(
 
         self,
-        transport: MsgTransport|None = None,
+        destaddr: tuple[str, int]|None,
+
+        msg_transport_type_key: tuple[str, str] = ('msgpack', 'tcp'),
+
         # TODO: optional reconnection support?
         # auto_reconnect: bool = False,
         # on_reconnect: typing.Callable[..., typing.Awaitable] = None,
@@ -89,16 +90,19 @@ class Channel:
         # self._recon_seq = on_reconnect
         # self._autorecon = auto_reconnect
 
+        self._destaddr = destaddr
+        self._transport_key = msg_transport_type_key
+
         # Either created in ``.connect()`` or passed in by
         # user in ``.from_stream()``.
-        self._transport: MsgTransport|None = transport
+        self._stream: trio.SocketStream|None = None
+        self._transport: MsgTransport|None = None
 
-        # set after handshake - always info from peer end
+        # set after handshake - always uid of far end
-        self.aid: Aid|None = None
+        self.uid: tuple[str, str]|None = None
 
         self._aiter_msgs = self._iter_msgs()
-        self._exc: Exception|None = None
+        self._exc: Exception|None = None  # set if far end actor errors
-        # ^XXX! ONLY set if a remote actor sends an `Error`-msg
         self._closed: bool = False
 
         # flag set by ``Portal.cancel_actor()`` indicating remote
@@ -106,33 +110,6 @@ class Channel:
         # runtime.
         self._cancel_called: bool = False
 
-    @property
-    def uid(self) -> tuple[str, str]:
-        '''
-        Peer actor's unique id.
-
-        '''
-        msg: str = (
-            f'`{type(self).__name__}.uid` is now deprecated.\n'
-            'Use the new `.aid: tractor.msg.Aid` (struct) instead '
-            'which also provides additional named (optional) fields '
-            'beyond just the `.name` and `.uuid`.'
-        )
-        warnings.warn(
-            msg,
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        peer_aid: Aid = self.aid
-        return (
-            peer_aid.name,
-            peer_aid.uuid,
-        )
-
-    @property
-    def stream(self) -> trio.abc.Stream | None:
-        return self._transport.stream if self._transport else None
-
     @property
     def msgstream(self) -> MsgTransport:
         log.info(
@@ -147,41 +124,52 @@ class Channel:
     @classmethod
     def from_stream(
         cls,
-        stream: trio.abc.Stream,
+        stream: trio.SocketStream,
-    ) -> Channel:
+        **kwargs,
-        transport_cls = transport_from_stream(stream)
-        return Channel(
-            transport=transport_cls(stream)
-        )
 
-    @classmethod
-    async def from_addr(
-        cls,
-        addr: UnwrappedAddress,
-        **kwargs
     ) -> Channel:
 
-        if not is_wrapped_addr(addr):
+        src, dst = get_stream_addrs(stream)
-            addr: Address = wrap_address(addr)
+        chan = Channel(
-
+            destaddr=dst,
-        transport_cls = transport_from_addr(addr)
-        transport = await transport_cls.connect_to(
-            addr,
             **kwargs,
         )
-        assert transport.raddr == addr
+
-        chan = Channel(transport=transport)
+        # set immediately here from provided instance
-        log.runtime(
+        chan._stream: trio.SocketStream = stream
-            f'Connected channel IPC transport\n'
+        chan.set_msg_transport(stream)
-            f'[>\n'
-            f' |_{chan}\n'
-        )
         return chan
 
+    def set_msg_transport(
+        self,
+        stream: trio.SocketStream,
+        type_key: tuple[str, str]|None = None,
+
+        # XXX optionally provided codec pair for `msgspec`:
+        # https://jcristharif.com/msgspec/extending.html#mapping-to-from-native-types
+        codec: MsgCodec|None = None,
+
+    ) -> MsgTransport:
+        type_key = (
+            type_key
+            or
+            self._transport_key
+        )
+        # get transport type, then
+        self._transport = get_msg_transport(
+            type_key
+        # instantiate an instance of the msg-transport
+        )(
+            stream,
+            codec=codec,
+        )
+        return self._transport
+
     @cm
     def apply_codec(
         self,
         codec: MsgCodec,
+
     ) -> None:
         '''
         Temporarily override the underlying IPC msg codec for
@@ -196,57 +184,49 @@ class Channel:
             self._transport.codec = orig
 
     # TODO: do a .src/.dst: str for maddrs?
-    def pformat(self) -> str:
+    def __repr__(self) -> str:
         if not self._transport:
             return '<Channel with inactive transport?>'
 
-        tpt: MsgTransport = self._transport
+        return repr(
-        tpt_name: str = type(tpt).__name__
+            self._transport.stream.socket._sock
-        tpt_status: str = (
+        ).replace(  # type: ignore
-            'connected' if self.connected()
+            "socket.socket",
-            else 'closed'
+            "Channel",
         )
-        return (
-            f'<Channel(\n'
-            f' |_status: {tpt_status!r}\n'
-            f'   _closed={self._closed}\n'
-            f'   _cancel_called={self._cancel_called}\n'
-            f'\n'
-            f' |_peer: {self.aid}\n'
-            f'\n'
-            f' |_msgstream: {tpt_name}\n'
-            f'   proto={tpt.laddr.proto_key!r}\n'
-            f'   layer={tpt.layer_key!r}\n'
-            f'   laddr={tpt.laddr}\n'
-            f'   raddr={tpt.raddr}\n'
-            f'   codec={tpt.codec_key!r}\n'
-            f'   stream={tpt.stream}\n'
-            f'   maddr={tpt.maddr!r}\n'
-            f'   drained={tpt.drained}\n'
-            f'   _send_lock={tpt._send_lock.statistics()}\n'
-            f')>\n'
-        )
-
-    # NOTE: making this return a value that can be passed to
-    # `eval()` is entirely **optional** FYI!
-    # https://docs.python.org/3/library/functions.html#repr
-    # https://docs.python.org/3/reference/datamodel.html#object.__repr__
-    #
-    # Currently we target **readability** from a (console)
-    # logging perspective over `eval()`-ability since we do NOT
-    # target serializing non-struct instances!
-    # def __repr__(self) -> str:
-    __str__ = pformat
-    __repr__ = pformat
 
     @property
-    def laddr(self) -> Address|None:
+    def laddr(self) -> tuple[str, int]|None:
         return self._transport.laddr if self._transport else None
 
     @property
-    def raddr(self) -> Address|None:
+    def raddr(self) -> tuple[str, int]|None:
         return self._transport.raddr if self._transport else None
 
+    async def connect(
+        self,
+        destaddr: tuple[Any, ...] | None = None,
+        **kwargs
+
+    ) -> MsgTransport:
+
+        if self.connected():
+            raise RuntimeError("channel is already connected?")
+
+        destaddr = destaddr or self._destaddr
+        assert isinstance(destaddr, tuple)
+
+        stream = await trio.open_tcp_stream(
+            *destaddr,
+            **kwargs
+        )
+        transport = self.set_msg_transport(stream)
+
+        log.transport(
+            f'Opened channel[{type(transport)}]: {self.laddr} -> {self.raddr}'
+        )
+        return transport
+
     # TODO: something like,
     # `pdbp.hideframe_on(errors=[MsgTypeError])`
     # instead of the `try/except` hack we have rn..
@@ -257,7 +237,7 @@ class Channel:
         self,
         payload: Any,
 
-        hide_tb: bool = True,
+        hide_tb: bool = False,
 
     ) -> None:
         '''
@@ -275,27 +255,14 @@ class Channel:
                 payload,
                 hide_tb=hide_tb,
             )
-        except (
+        except BaseException as _err:
-            BaseException,
-            MsgTypeError,
-            TransportClosed,
-        )as _err:
             err = _err  # bind for introspection
-            match err:
+            if not isinstance(_err, MsgTypeError):
-                case MsgTypeError():
+                # assert err
-                    try:
+                __tracebackhide__: bool = False
-                        assert err.cid
+            else:
-                    except KeyError:
+                assert err.cid
-                        raise err
-                case TransportClosed():
-                    log.transport(
-                        f'Transport stream closed due to\n'
-                        f'{err.repr_src_exc()}\n'
-                    )
 
-                case _:
-                    # never suppress non-tpt sources
-                    __tracebackhide__: bool = False
             raise
 
     async def recv(self) -> Any:
@@ -318,7 +285,7 @@ class Channel:
     async def aclose(self) -> None:
 
         log.transport(
-            f'Closing channel to {self.aid} '
+            f'Closing channel to {self.uid} '
             f'{self.laddr} -> {self.raddr}'
         )
         assert self._transport
@@ -418,40 +385,20 @@ class Channel:
     def connected(self) -> bool:
         return self._transport.connected() if self._transport else False
 
-    async def _do_handshake(
-        self,
-        aid: Aid,
-
-    ) -> Aid:
-        '''
-        Exchange `(name, UUIDs)` identifiers as the first
-        communication step with any (peer) remote `Actor`.
-
-        These are essentially the "mailbox addresses" found in
-        "actor model" parlance.
-
-        '''
-        await self.send(aid)
-        peer_aid: Aid = await self.recv()
-        log.runtime(
-            f'Received hanshake with peer actor,\n'
-            f'{peer_aid}\n'
-        )
-        # NOTE, we always are referencing the remote peer!
-        self.aid = peer_aid
-        return peer_aid
-
 
 @acm
 async def _connect_chan(
-    addr: UnwrappedAddress
+    host: str,
+    port: int
+
 ) -> typing.AsyncGenerator[Channel, None]:
     '''
     Create and connect a channel with disconnect on context manager
     teardown.
 
     '''
-    chan = await Channel.from_addr(addr)
+    chan = Channel((host, port))
+    await chan.connect()
     yield chan
     with trio.CancelScope(shield=True):
         await chan.aclose()

tractor/ipc/_fd_share.py

@@ -1,163 +0,0 @@
-# tractor: structured concurrent "actors".
-# Copyright 2018-eternity Tyler Goodlet.
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Affero General Public License for more details.
-
-# You should have received a copy of the GNU Affero General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-'''
-File-descriptor-sharing on `linux` by "wilhelm_of_bohemia".
-
-'''
-from __future__ import annotations
-import os
-import array
-import socket
-import tempfile
-from pathlib import Path
-from contextlib import ExitStack
-
-import trio
-import tractor
-from tractor.ipc import RBToken
-
-
-actor_name = 'ringd'
-
-
-_rings: dict[str, dict] = {}
-
-
-async def _attach_to_ring(
-    ring_name: str
-) -> tuple[int, int, int]:
-    actor = tractor.current_actor()
-
-    fd_amount = 3
-    sock_path = (
-        Path(tempfile.gettempdir())
-        /
-        f'{os.getpid()}-pass-ring-fds-{ring_name}-to-{actor.name}.sock'
-    )
-    sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-    sock.bind(sock_path)
-    sock.listen(1)
-
-    async with (
-        tractor.find_actor(actor_name) as ringd,
-        ringd.open_context(
-            _pass_fds,
-            name=ring_name,
-            sock_path=sock_path
-        ) as (ctx, _sent)
-    ):
-        # prepare array to receive FD
-        fds = array.array("i", [0] * fd_amount)
-
-        conn, _ = sock.accept()
-
-        # receive FD
-        msg, ancdata, flags, addr = conn.recvmsg(
-            1024,
-            socket.CMSG_LEN(fds.itemsize * fd_amount)
-        )
-
-        for (
-            cmsg_level,
-            cmsg_type,
-            cmsg_data,
-        ) in ancdata:
-            if (
-                cmsg_level == socket.SOL_SOCKET
-                and
-                cmsg_type == socket.SCM_RIGHTS
-            ):
-                fds.frombytes(cmsg_data[:fds.itemsize * fd_amount])
-                break
-            else:
-                raise RuntimeError("Receiver: No FDs received")
-
-        conn.close()
-        sock.close()
-        sock_path.unlink()
-
-        return RBToken.from_msg(
-            await ctx.wait_for_result()
-        )
-
-
-@tractor.context
-async def _pass_fds(
-    ctx: tractor.Context,
-    name: str,
-    sock_path: str
-) -> RBToken:
-    global _rings
-    token = _rings[name]
-    client = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-    client.connect(sock_path)
-    await ctx.started()
-    fds = array.array('i', token.fds)
-    client.sendmsg([b'FDs'], [(socket.SOL_SOCKET, socket.SCM_RIGHTS, fds)])
-    client.close()
-    return token
-
-
-@tractor.context
-async def _open_ringbuf(
-    ctx: tractor.Context,
-    name: str,
-    buf_size: int
-) -> RBToken:
-    global _rings
-    is_owner = False
-    if name not in _rings:
-        stack = ExitStack()
-        token = stack.enter_context(
-            tractor.open_ringbuf(
-                name,
-                buf_size=buf_size
-            )
-        )
-        _rings[name] = {
-            'token': token,
-            'stack': stack,
-        }
-        is_owner = True
-
-    ring = _rings[name]
-    await ctx.started()
-
-    try:
-        await trio.sleep_forever()
-
-    except tractor.ContextCancelled:
-        ...
-
-    finally:
-        if is_owner:
-            ring['stack'].close()
-
-
-async def open_ringbuf(
-    name: str,
-    buf_size: int
-) -> RBToken:
-    async with (
-        tractor.find_actor(actor_name) as ringd,
-        ringd.open_context(
-            _open_ringbuf,
-            name=name,
-            buf_size=buf_size
-        ) as (rd_ctx, _)
-    ):
-        yield await _attach_to_ring(name)
-        await rd_ctx.cancel()

tractor/ipc/_ringbuf/__init__.py

@@ -20,7 +20,6 @@ IPC Reliable RingBuffer implementation
 from __future__ import annotations
 import struct
 from typing import (
-    TypeVar,
     ContextManager,
     AsyncContextManager
 )
@@ -35,10 +34,6 @@ from msgspec import (
     Struct,
     to_builtins
 )
-from msgspec.msgpack import (
-    Encoder,
-    Decoder,
-)
 
 from tractor.log import get_logger
 from tractor._exceptions import (
@@ -72,7 +67,7 @@ class RBToken(Struct, frozen=True):
     even in the case that ringbuf was not allocated by current actor.
 
     '''
-    owner: str | None  # if owner != `current_actor().name` we must use fdshare
+    owner: str  # if owner != `current_actor().name` we must use fdshare
 
     shm_name: str
 
@@ -104,7 +99,6 @@ class RBToken(Struct, frozen=True):
 def alloc_ringbuf(
     shm_name: str,
     buf_size: int = _DEFAULT_RB_SIZE,
-    is_ipc: bool = True
 ) -> tuple[SharedMemory, RBToken]:
     '''
     Allocate OS resources for a ringbuf.
@@ -115,21 +109,18 @@ def alloc_ringbuf(
         create=True
     )
     token = RBToken(
-        owner=current_actor().name if is_ipc else None,
+        owner=current_actor().name,
         shm_name=shm_name,
         write_eventfd=open_eventfd(),
         wrap_eventfd=open_eventfd(),
         eof_eventfd=open_eventfd(),
         buf_size=buf_size
     )
-
+    # register fds for sharing
-    if is_ipc:
+    share_fds(
-        # register fds for sharing
+        shm_name,
-        share_fds(
+        token.fds,
-            shm_name,
+    )
-            token.fds,
-        )
-
     return shm, token
 
 
@@ -137,7 +128,6 @@ def alloc_ringbuf(
 def open_ringbuf_sync(
     shm_name: str,
     buf_size: int = _DEFAULT_RB_SIZE,
-    is_ipc: bool = True
 ) -> ContextManager[RBToken]:
     '''
     Handle resources for a ringbuf (shm, eventfd), yield `RBToken` to
@@ -148,15 +138,11 @@ def open_ringbuf_sync(
     shm: SharedMemory | None = None
     token: RBToken | None = None
     try:
-        shm, token = alloc_ringbuf(
+        shm, token = alloc_ringbuf(shm_name, buf_size=buf_size)
-            shm_name,
-            buf_size=buf_size,
-            is_ipc=is_ipc
-        )
         yield token
 
     finally:
-        if token and is_ipc:
+        if token:
             unshare_fds(shm_name)
 
         if shm:
@@ -166,7 +152,6 @@ def open_ringbuf_sync(
 async def open_ringbuf(
     shm_name: str,
     buf_size: int = _DEFAULT_RB_SIZE,
-    is_ipc: bool = True
 ) -> AsyncContextManager[RBToken]:
     '''
     Helper to use `open_ringbuf_sync` inside an async with block.
@@ -174,8 +159,7 @@ async def open_ringbuf(
     '''
     with open_ringbuf_sync(
         shm_name,
-        buf_size=buf_size,
+        buf_size=buf_size
-        is_ipc=is_ipc
     ) as token:
         yield token
 
@@ -184,7 +168,6 @@ async def open_ringbuf(
 def open_ringbufs_sync(
     shm_names: list[str],
     buf_sizes: int | list[str] = _DEFAULT_RB_SIZE,
-    is_ipc: bool = True
 ) -> ContextManager[tuple[RBToken]]:
     '''
     Handle resources for multiple ringbufs at once.
@@ -206,11 +189,7 @@ def open_ringbufs_sync(
 
     # allocate resources
     rings: list[tuple[SharedMemory, RBToken]] = [
-        alloc_ringbuf(
+        alloc_ringbuf(shm_name, buf_size=buf_size)
-            shm_name,
-            buf_size=buf_size,
-            is_ipc=is_ipc
-        )
         for shm_name, buf_size in zip(shm_names, buf_size)
     ]
 
@@ -220,12 +199,11 @@ def open_ringbufs_sync(
     finally:
         # attempt fd unshare and shm unlink for each
         for shm, token in rings:
-            if is_ipc:
+            try:
-                try:
+                unshare_fds(token.shm_name)
-                    unshare_fds(token.shm_name)
 
-                except RuntimeError:
+            except RuntimeError:
-                    log.exception(f'while unsharing fds of {token}')
+                log.exception(f'while unsharing fds of {token}')
 
             shm.unlink()
 
@@ -234,7 +212,6 @@ def open_ringbufs_sync(
 async def open_ringbufs(
     shm_names: list[str],
     buf_sizes: int | list[str] = _DEFAULT_RB_SIZE,
-    is_ipc: bool = True
 ) -> AsyncContextManager[tuple[RBToken]]:
     '''
     Helper to use `open_ringbufs_sync` inside an async with block.
@@ -242,8 +219,7 @@ async def open_ringbufs(
     '''
     with open_ringbufs_sync(
         shm_names,
-        buf_sizes=buf_sizes,
+        buf_sizes=buf_sizes
-        is_ipc=is_ipc
     ) as tokens:
         yield tokens
 
@@ -251,8 +227,7 @@ async def open_ringbufs(
 @cm
 def open_ringbuf_pair_sync(
     shm_name: str,
-    buf_size: int = _DEFAULT_RB_SIZE,
+    buf_size: int = _DEFAULT_RB_SIZE
-    is_ipc: bool = True
 ) -> ContextManager[tuple(RBToken, RBToken)]:
     '''
     Handle resources for a ringbuf pair to be used for
@@ -264,8 +239,7 @@ def open_ringbuf_pair_sync(
             f'{shm_name}.send',
             f'{shm_name}.recv'
         ],
-        buf_sizes=buf_size,
+        buf_sizes=buf_size
-        is_ipc=is_ipc
     ) as tokens:
         yield tokens
 
@@ -273,8 +247,7 @@ def open_ringbuf_pair_sync(
 @acm
 async def open_ringbuf_pair(
     shm_name: str,
-    buf_size: int = _DEFAULT_RB_SIZE,
+    buf_size: int = _DEFAULT_RB_SIZE
-    is_ipc: bool = True
 ) -> AsyncContextManager[tuple[RBToken, RBToken]]:
     '''
     Helper to use `open_ringbuf_pair_sync` inside an async with block.
@@ -282,8 +255,7 @@ async def open_ringbuf_pair(
     '''
     with open_ringbuf_pair_sync(
         shm_name,
-        buf_size=buf_size,
+        buf_size=buf_size
-        is_ipc=is_ipc
     ) as tokens:
         yield tokens
 
@@ -305,10 +277,7 @@ next full payload.
 '''
 
 
-PayloadT = TypeVar('PayloadT')
+class RingBufferSendChannel(trio.abc.SendChannel[bytes]):
-
-
-class RingBufferSendChannel(trio.abc.SendChannel[PayloadT]):
     '''
     Ring Buffer sender side implementation
 
@@ -329,8 +298,7 @@ class RingBufferSendChannel(trio.abc.SendChannel[PayloadT]):
         self,
         token: RBToken,
         batch_size: int = 1,
-        cleanup: bool = False,
+        cleanup: bool = False
-        encoder: Encoder | None = None
     ):
         self._token = RBToken.from_msg(token)
         self.batch_size = batch_size
@@ -351,8 +319,6 @@ class RingBufferSendChannel(trio.abc.SendChannel[PayloadT]):
         # close shm & fds on exit?
         self._cleanup: bool = cleanup
 
-        self._enc: Encoder | None = encoder
-
         # have we closed this ringbuf?
         # set to `False` on `.open()`
         self._is_closed: bool = True
@@ -449,22 +415,15 @@ class RingBufferSendChannel(trio.abc.SendChannel[PayloadT]):
             if new_batch_size:
                 self.batch_size = new_batch_size
 
-    async def send(self, value: PayloadT) -> None:
+    async def send(self, value: bytes) -> None:
         if self.closed:
             raise trio.ClosedResourceError
 
         if self._send_lock.locked():
             raise trio.BusyResourceError
 
-        raw_value: bytes = (
-            value
-            if isinstance(value, bytes)
-            else
-            self._enc.encode(value)
-        )
-
         async with self._send_lock:
-            msg: bytes = struct.pack("<I", len(raw_value)) + raw_value
+            msg: bytes = struct.pack("<I", len(value)) + value
             if self.batch_size == 1:
                 if len(self._batch) > 0:
                     await self.flush()
@@ -516,7 +475,7 @@ class RingBufferSendChannel(trio.abc.SendChannel[PayloadT]):
         return self
 
 
-class RingBufferReceiveChannel(trio.abc.ReceiveChannel[PayloadT]):
+class RingBufferReceiveChannel(trio.abc.ReceiveChannel[bytes]):
     '''
     Ring Buffer receiver side implementation
 
@@ -528,7 +487,6 @@ class RingBufferReceiveChannel(trio.abc.ReceiveChannel[PayloadT]):
         self,
         token: RBToken,
         cleanup: bool = True,
-        decoder: Decoder | None = None
     ):
         self._token = RBToken.from_msg(token)
 
@@ -555,8 +513,6 @@ class RingBufferReceiveChannel(trio.abc.ReceiveChannel[PayloadT]):
         # set to `False` on `.open()`
         self._is_closed: bool = True
 
-        self._dec: Decoder | None = decoder
-
         # ensure no concurrent `.receive_some()` calls
         self._receive_some_lock = trio.StrictFIFOLock()
 
@@ -692,11 +648,7 @@ class RingBufferReceiveChannel(trio.abc.ReceiveChannel[PayloadT]):
                         self._write_ptr += delta
                         # yield lock and re-enter
 
-                    except (
+                    except (EFDReadCancelled, trio.Cancelled):
-                        EFDReadCancelled,  # read was cancelled with cscope
-                        trio.Cancelled,  # read got cancelled from outside
-                        trio.BrokenResourceError  # OSError EBADF happened while reading
-                    ):
                         # while waiting for new data `self._write_event` was closed
                         try:
                             # if eof was signaled receive no wait will not raise
@@ -747,7 +699,7 @@ class RingBufferReceiveChannel(trio.abc.ReceiveChannel[PayloadT]):
 
             return payload
 
-    async def receive(self, raw: bool = False) -> PayloadT:
+    async def receive(self) -> bytes:
         '''
         Receive a complete payload or raise EOC
 
@@ -765,27 +717,7 @@ class RingBufferReceiveChannel(trio.abc.ReceiveChannel[PayloadT]):
             if size == 0:
                 raise trio.EndOfChannel
 
-            raw_msg = await self.receive_exactly(size)
+            return await self.receive_exactly(size)
-            if raw:
-                return raw_msg
-
-            return (
-                raw_msg
-                if not self._dec
-                else self._dec.decode(raw_msg)
-            )
-
-    async def iter_raw_pairs(self) -> tuple[bytes, PayloadT]:
-        if not self._dec:
-            raise RuntimeError('iter_raw_pair requires decoder')
-
-        while True:
-            try:
-                raw = await self.receive(raw=True)
-                yield raw, self._dec.decode(raw)
-
-            except trio.EndOfChannel:
-                break
 
     def open(self):
         try:
@@ -850,9 +782,7 @@ async def _maybe_obtain_shared_resources(token: RBToken):
 async def attach_to_ringbuf_receiver(
 
     token: RBToken,
-    cleanup: bool = True,
+    cleanup: bool = True
-    decoder: Decoder | None = None,
-    is_ipc: bool = True
 
 ) -> AsyncContextManager[RingBufferReceiveChannel]:
     '''
@@ -864,15 +794,13 @@ async def attach_to_ringbuf_receiver(
 
     Launches `receiver._eof_monitor_task` in a `trio.Nursery`.
     '''
-    if is_ipc:
+    token = await _maybe_obtain_shared_resources(token)
-        token = await _maybe_obtain_shared_resources(token)
 
     async with (
         trio.open_nursery(strict_exception_groups=False) as n,
         RingBufferReceiveChannel(
             token,
-            cleanup=cleanup,
+            cleanup=cleanup
-            decoder=decoder
         ) as receiver
     ):
         n.start_soon(receiver._eof_monitor_task)
@@ -884,9 +812,7 @@ async def attach_to_ringbuf_sender(
 
     token: RBToken,
     batch_size: int = 1,
-    cleanup: bool = True,
+    cleanup: bool = True
-    encoder: Encoder | None = None,
-    is_ipc: bool = True
 
 ) -> AsyncContextManager[RingBufferSendChannel]:
     '''
@@ -897,14 +823,12 @@ async def attach_to_ringbuf_sender(
     originally allocated by a different actor.
 
     '''
-    if is_ipc:
+    token = await _maybe_obtain_shared_resources(token)
-        token = await _maybe_obtain_shared_resources(token)
 
     async with RingBufferSendChannel(
         token,
         batch_size=batch_size,
-        cleanup=cleanup,
+        cleanup=cleanup
-        encoder=encoder
     ) as sender:
         yield sender
 
@@ -977,10 +901,6 @@ async def attach_to_ringbuf_channel(
     batch_size: int = 1,
     cleanup_in: bool = True,
     cleanup_out: bool = True,
-    encoder: Encoder | None = None,
-    decoder: Decoder | None = None,
-    sender_ipc: bool = True,
-    receiver_ipc: bool = True
 ) -> AsyncContextManager[trio.StapledStream]:
     '''
     Attach to two previously opened `RBToken`s and return a `RingBufferChannel`
@@ -989,16 +909,12 @@ async def attach_to_ringbuf_channel(
     async with (
         attach_to_ringbuf_receiver(
             token_in,
-            cleanup=cleanup_in,
+            cleanup=cleanup_in
-            decoder=decoder,
-            is_ipc=receiver_ipc
         ) as receiver,
         attach_to_ringbuf_sender(
             token_out,
             batch_size=batch_size,
-            cleanup=cleanup_out,
+            cleanup=cleanup_out
-            encoder=encoder,
-            is_ipc=sender_ipc
         ) as sender,
     ):
         yield RingBufferChannel(sender, receiver)

tractor/ipc/_ringbuf/_pubsub.py

@@ -31,14 +31,8 @@ from dataclasses import dataclass
 import trio
 import tractor
 
-from msgspec.msgpack import (
-    Encoder,
-    Decoder
-)
-
 from tractor.ipc._ringbuf import (
     RBToken,
-    PayloadT,
     RingBufferSendChannel,
     RingBufferReceiveChannel,
     attach_to_ringbuf_sender,
@@ -248,7 +242,6 @@ class ChannelManager(Generic[ChannelType]):
             if info.channel.closed:
                 continue
 
-            await info.channel.aclose()
             await self.remove_channel(info.token.shm_name)
 
         self._is_closed = True
@@ -260,7 +253,7 @@ Ring buffer publisher & subscribe pattern mediated by `ringd` actor.
 '''
 
 
-class RingBufferPublisher(trio.abc.SendChannel[PayloadT]):
+class RingBufferPublisher(trio.abc.SendChannel[bytes]):
     '''
     Use ChannelManager to create a multi ringbuf round robin sender that can
     dynamically add or remove more outputs.
@@ -277,16 +270,13 @@ class RingBufferPublisher(trio.abc.SendChannel[PayloadT]):
         msgs_per_turn: int = 1,
 
         # global batch size for all channels
-        batch_size: int = 1,
+        batch_size: int = 1
-
-        encoder: Encoder | None = None
     ):
         self._batch_size: int = batch_size
         self.msgs_per_turn = msgs_per_turn
-        self._enc = encoder
 
         # helper to manage acms + long running tasks
-        self._chanmngr = ChannelManager[RingBufferSendChannel[PayloadT]](
+        self._chanmngr = ChannelManager[RingBufferSendChannel](
             n,
             self._open_channel,
             self._channel_task
@@ -359,11 +349,10 @@ class RingBufferPublisher(trio.abc.SendChannel[PayloadT]):
         self,
         token: RBToken
 
-    ) -> AsyncContextManager[RingBufferSendChannel[PayloadT]]:
+    ) -> AsyncContextManager[RingBufferSendChannel]:
         async with attach_to_ringbuf_sender(
             token,
-            batch_size=self._batch_size,
+            batch_size=self._batch_size
-            encoder=self._enc
         ) as ring:
             yield ring
 
@@ -398,7 +387,7 @@ class RingBufferPublisher(trio.abc.SendChannel[PayloadT]):
             info = self.channels[turn]
             await info.channel.send(msg)
 
-    async def broadcast(self, msg: PayloadT):
+    async def broadcast(self, msg: bytes):
         '''
         Send a msg to all channels, if no channels connected, does nothing.
         '''
@@ -417,8 +406,8 @@ class RingBufferPublisher(trio.abc.SendChannel[PayloadT]):
                 ...
 
     async def __aenter__(self):
-        self._is_closed = False
         self._chanmngr.open()
+        self._is_closed = False
         return self
 
     async def aclose(self) -> None:
@@ -431,7 +420,7 @@ class RingBufferPublisher(trio.abc.SendChannel[PayloadT]):
         self._is_closed = True
 
 
-class RingBufferSubscriber(trio.abc.ReceiveChannel[PayloadT]):
+class RingBufferSubscriber(trio.abc.ReceiveChannel[bytes]):
     '''
     Use ChannelManager to create a multi ringbuf receiver that can
     dynamically add or remove more inputs and combine all into a single output.
@@ -451,10 +440,11 @@ class RingBufferSubscriber(trio.abc.ReceiveChannel[PayloadT]):
         self,
         n: trio.Nursery,
 
-        decoder: Decoder | None = None
+        # if connecting to a publisher that has already sent messages set 
+        # to the next expected payload index this subscriber will receive
+        start_index: int = 0
     ):
-        self._dec = decoder
+        self._chanmngr = ChannelManager[RingBufferReceiveChannel](
-        self._chanmngr = ChannelManager[RingBufferReceiveChannel[PayloadT]](
             n,
             self._open_channel,
             self._channel_task
@@ -493,10 +483,7 @@ class RingBufferSubscriber(trio.abc.ReceiveChannel[PayloadT]):
         token: RBToken
 
     ) -> AsyncContextManager[RingBufferSendChannel]:
-        async with attach_to_ringbuf_receiver(
+        async with attach_to_ringbuf_receiver(token) as ring:
-            token,
-            decoder=self._dec
-        ) as ring:
             yield ring
 
     async def _channel_task(self, info: ChannelInfo) -> None:
@@ -522,7 +509,7 @@ class RingBufferSubscriber(trio.abc.ReceiveChannel[PayloadT]):
             except trio.ClosedResourceError:
                 break
 
-    async def receive(self) -> PayloadT:
+    async def receive(self) -> bytes:
         '''
         Receive next in order msg
         '''
@@ -556,74 +543,73 @@ Actor module for managing publisher & subscriber channels remotely through
 `tractor.context` rpc
 '''
 
-@dataclass
+_publisher: RingBufferPublisher | None = None
-class PublisherEntry:
+_subscriber: RingBufferSubscriber | None = None
-    publisher: RingBufferPublisher | None = None
-    is_set: trio.Event = trio.Event()
 
 
-_publishers: dict[str, PublisherEntry] = {}
+def set_publisher(pub: RingBufferPublisher):
+    global _publisher
 
-
+    if _publisher:
-def maybe_init_publisher(topic: str) -> PublisherEntry:
-    entry = _publishers.get(topic, None)
-    if not entry:
-        entry = PublisherEntry()
-        _publishers[topic] = entry
-
-    return entry
-
-
-def set_publisher(topic: str, pub: RingBufferPublisher):
-    global _publishers
-
-    entry = _publishers.get(topic, None)
-    if not entry:
-        entry = maybe_init_publisher(topic)
-
-    if entry.publisher:
         raise RuntimeError(
-            f'publisher for topic {topic} already set on {tractor.current_actor()}'
+            f'publisher already set on {tractor.current_actor()}'
         )
 
-    entry.publisher = pub
+    _publisher = pub
-    entry.is_set.set()
 
 
-def get_publisher(topic: str = 'default') -> RingBufferPublisher:
+def set_subscriber(sub: RingBufferSubscriber):
-    entry = _publishers.get(topic, None)
+    global _subscriber
-    if not entry or not entry.publisher:
+
+    if _subscriber:
+        raise RuntimeError(
+            f'subscriber already set on {tractor.current_actor()}'
+        )
+
+    _subscriber = sub
+
+
+def get_publisher() -> RingBufferPublisher:
+    global _publisher
+
+    if not _publisher:
         raise RuntimeError(
             f'{tractor.current_actor()} tried to get publisher'
             'but it\'s not set'
         )
 
-    return entry.publisher
+    return _publisher
 
 
-async def wait_publisher(topic: str) -> RingBufferPublisher:
+def get_subscriber() -> RingBufferSubscriber:
-    entry = maybe_init_publisher(topic)
+    global _subscriber
-    await entry.is_set.wait()
+
-    return entry.publisher
+    if not _subscriber:
+        raise RuntimeError(
+            f'{tractor.current_actor()} tried to get subscriber'
+            'but it\'s not set'
+        )
+
+    return _subscriber
 
 
 @tractor.context
 async def _add_pub_channel(
     ctx: tractor.Context,
-    topic: str,
     token: RBToken
 ):
-    publisher = await wait_publisher(topic)
+    publisher = get_publisher()
+    await ctx.started()
     await publisher.add_channel(token)
 
 
 @tractor.context
 async def _remove_pub_channel(
     ctx: tractor.Context,
-    topic: str,
     ring_name: str
 ):
-    publisher = await wait_publisher(topic)
+    publisher = get_publisher()
+    await ctx.started()
     maybe_token = fdshare.maybe_get_fds(ring_name)
     if maybe_token:
         await publisher.remove_channel(ring_name)
@@ -633,92 +619,59 @@ async def _remove_pub_channel(
 async def open_pub_channel_at(
     actor_name: str,
     token: RBToken,
-    topic: str = 'default',
+    cleanup: bool = True,
 ):
-    async with tractor.find_actor(actor_name) as portal:
+    async with (
-        await portal.run(_add_pub_channel, topic=topic, token=token)
+        tractor.find_actor(actor_name) as portal,
-        try:
-            yield
 
-        except trio.Cancelled:
+        portal.open_context(
-            log.warning(
+            _add_pub_channel,
-                'open_pub_channel_at got cancelled!\n'
+            token=token
-                f'\tactor_name = {actor_name}\n'
+        ) as (ctx, _)
-                f'\ttoken = {token}\n'
+    ):
-            )
+        ...
-            raise
 
-        await portal.run(_remove_pub_channel, topic=topic, ring_name=token.shm_name)
+    try:
+        yield
 
-
+    except trio.Cancelled:
-@dataclass
+        log.warning(
-class SubscriberEntry:
+            'open_pub_channel_at got cancelled!\n'
-    subscriber: RingBufferSubscriber | None = None
+            f'\tactor_name = {actor_name}\n'
-    is_set: trio.Event = trio.Event()
+            f'\ttoken = {token}\n'
-
-
-_subscribers: dict[str, SubscriberEntry] = {}
-
-
-def maybe_init_subscriber(topic: str) -> SubscriberEntry:
-    entry = _subscribers.get(topic, None)
-    if not entry:
-        entry = SubscriberEntry()
-        _subscribers[topic] = entry
-
-    return entry
-
-
-def set_subscriber(topic: str, sub: RingBufferSubscriber):
-    global _subscribers
-
-    entry = _subscribers.get(topic, None)
-    if not entry:
-        entry = maybe_init_subscriber(topic)
-
-    if entry.subscriber:
-        raise RuntimeError(
-            f'subscriber for topic {topic} already set on {tractor.current_actor()}'
         )
+        raise
 
-    entry.subscriber = sub
+    finally:
-    entry.is_set.set()
+        if not cleanup:
+            return
 
-
+        async with tractor.find_actor(actor_name) as portal:
-def get_subscriber(topic: str = 'default') -> RingBufferSubscriber:
+            if portal:
-    entry = _subscribers.get(topic, None)
+                async with portal.open_context(
-    if not entry or not entry.subscriber:
+                    _remove_pub_channel,
-        raise RuntimeError(
+                    ring_name=token.shm_name
-            f'{tractor.current_actor()} tried to get subscriber'
+                ) as (ctx, _):
-            'but it\'s not set'
+                    ...
-        )
-
-    return entry.subscriber
-
-
-async def wait_subscriber(topic: str) -> RingBufferSubscriber:
-    entry = maybe_init_subscriber(topic)
-    await entry.is_set.wait()
-    return entry.subscriber
 
 
 @tractor.context
 async def _add_sub_channel(
     ctx: tractor.Context,
-    topic: str,
     token: RBToken
 ):
-    subscriber = await wait_subscriber(topic)
+    subscriber = get_subscriber()
+    await ctx.started()
     await subscriber.add_channel(token)
 
 
 @tractor.context
 async def _remove_sub_channel(
     ctx: tractor.Context,
-    topic: str,
     ring_name: str
 ):
-    subscriber = await wait_subscriber(topic)
+    subscriber = get_subscriber()
+    await ctx.started()
     maybe_token = fdshare.maybe_get_fds(ring_name)
     if maybe_token:
         await subscriber.remove_channel(ring_name)
@@ -728,22 +681,41 @@ async def _remove_sub_channel(
 async def open_sub_channel_at(
     actor_name: str,
     token: RBToken,
-    topic: str = 'default',
+    cleanup: bool = True,
 ):
-    async with tractor.find_actor(actor_name) as portal:
+    async with (
-        await portal.run(_add_sub_channel, topic=topic, token=token)
+        tractor.find_actor(actor_name) as portal,
-        try:
-            yield
 
-        except trio.Cancelled:
+        portal.open_context(
-            log.warning(
+            _add_sub_channel,
-                'open_sub_channel_at got cancelled!\n'
+            token=token
-                f'\tactor_name = {actor_name}\n'
+        ) as (ctx, _)
-                f'\ttoken = {token}\n'
+    ):
-            )
+        ...
-            raise
+
+    try:
+        yield
+
+    except trio.Cancelled:
+        log.warning(
+            'open_sub_channel_at got cancelled!\n'
+            f'\tactor_name = {actor_name}\n'
+            f'\ttoken = {token}\n'
+        )
+        raise
+
+    finally:
+        if not cleanup:
+            return
+
+        async with tractor.find_actor(actor_name) as portal:
+            if portal:
+                async with portal.open_context(
+                    _remove_sub_channel,
+                    ring_name=token.shm_name
+                ) as (ctx, _):
+                    ...
 
-        await portal.run(_remove_sub_channel, topic=topic, ring_name=token.shm_name)
 
 
 '''
@@ -753,17 +725,12 @@ High level helpers to open publisher & subscriber
 
 @acm
 async def open_ringbuf_publisher(
-    # name to distinguish this publisher
-    topic: str = 'default',
-
     # global batch size for channels
     batch_size: int = 1,
 
     # messages before changing output channel
     msgs_per_turn: int = 1,
 
-    encoder: Encoder | None = None,
-
     # ensure subscriber receives in same order publisher sent
     # causes it to use wrapped payloads which contain the og
     # index
@@ -783,28 +750,26 @@ async def open_ringbuf_publisher(
         trio.open_nursery(strict_exception_groups=False) as n,
         RingBufferPublisher(
             n,
-            batch_size=batch_size,
+            batch_size=batch_size
-            encoder=encoder,
         ) as publisher
     ):
         if guarantee_order:
             order_send_channel(publisher)
 
         if set_module_var:
-            set_publisher(topic, publisher)
+            set_publisher(publisher)
 
-        yield publisher
+        try:
+            yield publisher
 
-        n.cancel_scope.cancel()
+        except trio.Cancelled:
+            with trio.CancelScope(shield=True):
+                await publisher.aclose()
+            raise
 
 
 @acm
 async def open_ringbuf_subscriber(
-    # name to distinguish this subscriber
-    topic: str = 'default',
-
-    decoder: Decoder | None = None,
-
     # expect indexed payloads and unwrap them in order
     guarantee_order: bool = False,
 
@@ -819,7 +784,7 @@ async def open_ringbuf_subscriber(
     '''
     async with (
         trio.open_nursery(strict_exception_groups=False) as n,
-        RingBufferSubscriber(n, decoder=decoder) as subscriber
+        RingBufferSubscriber(n) as subscriber
     ):
         # maybe monkey patch `.receive` to use indexed payloads
         if guarantee_order:
@@ -827,8 +792,13 @@ async def open_ringbuf_subscriber(
 
         # maybe set global module var for remote actor channel updates
         if set_module_var:
-            set_subscriber(topic, subscriber)
+            global _subscriber
+            set_subscriber(subscriber)
 
-        yield subscriber
+        try:
+            yield subscriber
 
-        n.cancel_scope.cancel()
+        except trio.Cancelled:
+            with trio.CancelScope(shield=True):
+                await subscriber.aclose()
+            raise

tractor/ipc/_shm.py

@@ -50,10 +50,7 @@ if _USE_POSIX:
 try:
     import numpy as np
     from numpy.lib import recfunctions as rfn
-    # TODO ruff complains with,
+    import nptyping
-    # warning| F401: `nptyping` imported but unused; consider using
-    # `importlib.util.find_spec` to test for availability
-    import nptyping  # noqa
 except ImportError:
     pass
 

tractor/ipc/_tcp.py

@@ -18,195 +18,388 @@ TCP implementation of tractor.ipc._transport.MsgTransport protocol
 
 '''
 from __future__ import annotations
-from typing import (
+from collections.abc import (
-    ClassVar,
+    AsyncGenerator,
+    AsyncIterator,
+)
+import struct
+from typing import (
+    Any,
+    Callable,
 )
-# from contextlib import (
-#     asynccontextmanager as acm,
-# )
 
 import msgspec
+from tricycle import BufferedReceiveStream
 import trio
-from trio import (
-    SocketListener,
-    open_tcp_listeners,
-)
 
-from tractor.msg import MsgCodec
 from tractor.log import get_logger
-from tractor.ipc._transport import (
+from tractor._exceptions import (
-    MsgTransport,
+    MsgTypeError,
-    MsgpackTransport,
+    TransportClosed,
+    _mk_send_mte,
+    _mk_recv_mte,
 )
+from tractor.msg import (
+    _ctxvar_MsgCodec,
+    # _codec,  XXX see `self._codec` sanity/debug checks
+    MsgCodec,
+    types as msgtypes,
+    pretty_struct,
+)
+from tractor.ipc import MsgTransport
 
 
 log = get_logger(__name__)
 
 
-class TCPAddress(
+def get_stream_addrs(
-    msgspec.Struct,
+    stream: trio.SocketStream
-    frozen=True,
+) -> tuple[
-):
+    tuple[str, int],  # local
-    _host: str
+    tuple[str, int],  # remote
-    _port: int
+]:
-
-    proto_key: ClassVar[str] = 'tcp'
-    unwrapped_type: ClassVar[type] = tuple[str, int]
-    def_bindspace: ClassVar[str] = '127.0.0.1'
-
-    @property
-    def is_valid(self) -> bool:
-        return self._port != 0
-
-    @property
-    def bindspace(self) -> str:
-        return self._host
-
-    @property
-    def domain(self) -> str:
-        return self._host
-
-    @classmethod
-    def from_addr(
-        cls,
-        addr: tuple[str, int]
-    ) -> TCPAddress:
-        match addr:
-            case (str(), int()):
-                return TCPAddress(addr[0], addr[1])
-            case _:
-                raise ValueError(
-                    f'Invalid unwrapped address for {cls}\n'
-                    f'{addr}\n'
-                )
-
-    def unwrap(self) -> tuple[str, int]:
-        return (
-            self._host,
-            self._port,
-        )
-
-    @classmethod
-    def get_random(
-        cls,
-        bindspace: str = def_bindspace,
-    ) -> TCPAddress:
-        return TCPAddress(bindspace, 0)
-
-    @classmethod
-    def get_root(cls) -> TCPAddress:
-        return TCPAddress(
-            '127.0.0.1',
-            1616,
-        )
-
-    def __repr__(self) -> str:
-        return (
-            f'{type(self).__name__}[{self.unwrap()}]'
-        )
-
-    @classmethod
-    def get_transport(
-        cls,
-        codec: str = 'msgpack',
-    ) -> MsgTransport:
-        match codec:
-            case 'msgspack':
-                return MsgpackTCPStream
-            case _:
-                raise ValueError(
-                    f'No IPC transport with {codec!r} supported !'
-                )
-
-
-async def start_listener(
-    addr: TCPAddress,
-    **kwargs,
-) -> SocketListener:
     '''
-    Start a TCP socket listener on the given `TCPAddress`.
+    Return the `trio` streaming transport prot's socket-addrs for
+    both the local and remote sides as a pair.
 
     '''
-    # ?TODO, maybe we should just change the lower-level call this is
+    # rn, should both be IP sockets
-    # using internall per-listener?
+    lsockname = stream.socket.getsockname()
-    listeners: list[SocketListener] = await open_tcp_listeners(
+    rsockname = stream.socket.getpeername()
-        host=addr._host,
+    return (
-        port=addr._port,
+        tuple(lsockname[:2]),
-        **kwargs
+        tuple(rsockname[:2]),
     )
-    # NOTE, for now we don't expect non-singleton-resolving
-    # domain-addresses/multi-homed-hosts.
-    # (though it is supported by `open_tcp_listeners()`)
-    assert len(listeners) == 1
-    listener = listeners[0]
-    host, port = listener.socket.getsockname()[:2]
-    return listener
 
 
 # TODO: typing oddity.. not sure why we have to inherit here, but it
 # seems to be an issue with `get_msg_transport()` returning
 # a `Type[Protocol]`; probably should make a `mypy` issue?
-class MsgpackTCPStream(MsgpackTransport):
+class MsgpackTCPStream(MsgTransport):
     '''
     A ``trio.SocketStream`` delivering ``msgpack`` formatted data
     using the ``msgspec`` codec lib.
 
     '''
-    address_type = TCPAddress
     layer_key: int = 4
+    name_key: str = 'tcp'
+
+    # TODO: better naming for this?
+    # -[ ] check how libp2p does naming for such things?
+    codec_key: str = 'msgpack'
+
+    def __init__(
+        self,
+        stream: trio.SocketStream,
+        prefix_size: int = 4,
+
+        # XXX optionally provided codec pair for `msgspec`:
+        # https://jcristharif.com/msgspec/extending.html#mapping-to-from-native-types
+        #
+        # TODO: define this as a `Codec` struct which can be
+        # overriden dynamically by the application/runtime?
+        codec: tuple[
+            Callable[[Any], Any]|None,  # coder
+            Callable[[type, Any], Any]|None,  # decoder
+        ]|None = None,
+
+    ) -> None:
+
+        self.stream = stream
+        assert self.stream.socket
+
+        # should both be IP sockets
+        self._laddr, self._raddr = get_stream_addrs(stream)
+
+        # create read loop instance
+        self._aiter_pkts = self._iter_packets()
+        self._send_lock = trio.StrictFIFOLock()
+
+        # public i guess?
+        self.drained: list[dict] = []
+
+        self.recv_stream = BufferedReceiveStream(
+            transport_stream=stream
+        )
+        self.prefix_size = prefix_size
+
+        # allow for custom IPC msg interchange format
+        # dynamic override Bo
+        self._task = trio.lowlevel.current_task()
+
+        # XXX for ctxvar debug only!
+        # self._codec: MsgCodec = (
+        #     codec
+        #     or
+        #     _codec._ctxvar_MsgCodec.get()
+        # )
+
+    async def _iter_packets(self) -> AsyncGenerator[dict, None]:
+        '''
+        Yield `bytes`-blob decoded packets from the underlying TCP
+        stream using the current task's `MsgCodec`.
+
+        This is a streaming routine implemented as an async generator
+        func (which was the original design, but could be changed?)
+        and is allocated by a `.__call__()` inside `.__init__()` where
+        it is assigned to the `._aiter_pkts` attr.
+
+        '''
+        decodes_failed: int = 0
+
+        while True:
+            try:
+                header: bytes = await self.recv_stream.receive_exactly(4)
+            except (
+                ValueError,
+                ConnectionResetError,
+
+                # not sure entirely why we need this but without it we
+                # seem to be getting racy failures here on
+                # arbiter/registry name subs..
+                trio.BrokenResourceError,
+
+            ) as trans_err:
+
+                loglevel = 'transport'
+                match trans_err:
+                    # case (
+                    #     ConnectionResetError()
+                    # ):
+                    #     loglevel = 'transport'
+
+                    # peer actor (graceful??) TCP EOF but `tricycle`
+                    # seems to raise a 0-bytes-read?
+                    case ValueError() if (
+                        'unclean EOF' in trans_err.args[0]
+                    ):
+                        pass
+
+                    # peer actor (task) prolly shutdown quickly due
+                    # to cancellation
+                    case trio.BrokenResourceError() if (
+                        'Connection reset by peer' in trans_err.args[0]
+                    ):
+                        pass
+
+                    # unless the disconnect condition falls under "a
+                    # normal operation breakage" we usualy console warn
+                    # about it.
+                    case _:
+                        loglevel: str = 'warning'
+
+
+                raise TransportClosed(
+                    message=(
+                        f'IPC transport already closed by peer\n'
+                        f'x)> {type(trans_err)}\n'
+                        f' |_{self}\n'
+                    ),
+                    loglevel=loglevel,
+                ) from trans_err
+
+            # XXX definitely can happen if transport is closed
+            # manually by another `trio.lowlevel.Task` in the
+            # same actor; we use this in some simulated fault
+            # testing for ex, but generally should never happen
+            # under normal operation!
+            #
+            # NOTE: as such we always re-raise this error from the
+            #       RPC msg loop!
+            except trio.ClosedResourceError as closure_err:
+                raise TransportClosed(
+                    message=(
+                        f'IPC transport already manually closed locally?\n'
+                        f'x)> {type(closure_err)} \n'
+                        f' |_{self}\n'
+                    ),
+                    loglevel='error',
+                    raise_on_report=(
+                        closure_err.args[0] == 'another task closed this fd'
+                        or
+                        closure_err.args[0] in ['another task closed this fd']
+                    ),
+                ) from closure_err
+
+            # graceful TCP EOF disconnect
+            if header == b'':
+                raise TransportClosed(
+                    message=(
+                        f'IPC transport already gracefully closed\n'
+                        f')>\n'
+                        f'|_{self}\n'
+                    ),
+                    loglevel='transport',
+                    # cause=???  # handy or no?
+                )
+
+            size: int
+            size, = struct.unpack("<I", header)
+
+            log.transport(f'received header {size}')  # type: ignore
+            msg_bytes: bytes = await self.recv_stream.receive_exactly(size)
+
+            log.transport(f"received {msg_bytes}")  # type: ignore
+            try:
+                # NOTE: lookup the `trio.Task.context`'s var for
+                # the current `MsgCodec`.
+                codec: MsgCodec = _ctxvar_MsgCodec.get()
+
+                # XXX for ctxvar debug only!
+                # if self._codec.pld_spec != codec.pld_spec:
+                #     assert (
+                #         task := trio.lowlevel.current_task()
+                #     ) is not self._task
+                #     self._task = task
+                #     self._codec = codec
+                #     log.runtime(
+                #         f'Using new codec in {self}.recv()\n'
+                #         f'codec: {self._codec}\n\n'
+                #         f'msg_bytes: {msg_bytes}\n'
+                #     )
+                yield codec.decode(msg_bytes)
+
+            # XXX NOTE: since the below error derives from
+            # `DecodeError` we need to catch is specially
+            # and always raise such that spec violations
+            # are never allowed to be caught silently!
+            except msgspec.ValidationError as verr:
+                msgtyperr: MsgTypeError = _mk_recv_mte(
+                    msg=msg_bytes,
+                    codec=codec,
+                    src_validation_error=verr,
+                )
+                # XXX deliver up to `Channel.recv()` where
+                # a re-raise and `Error`-pack can inject the far
+                # end actor `.uid`.
+                yield msgtyperr
+
+            except (
+                msgspec.DecodeError,
+                UnicodeDecodeError,
+            ):
+                if decodes_failed < 4:
+                    # ignore decoding errors for now and assume they have to
+                    # do with a channel drop - hope that receiving from the
+                    # channel will raise an expected error and bubble up.
+                    try:
+                        msg_str: str|bytes = msg_bytes.decode()
+                    except UnicodeDecodeError:
+                        msg_str = msg_bytes
+
+                    log.exception(
+                        'Failed to decode msg?\n'
+                        f'{codec}\n\n'
+                        'Rxed bytes from wire:\n\n'
+                        f'{msg_str!r}\n'
+                    )
+                    decodes_failed += 1
+                else:
+                    raise
+
+    async def send(
+        self,
+        msg: msgtypes.MsgType,
+
+        strict_types: bool = True,
+        hide_tb: bool = False,
+
+    ) -> None:
+        '''
+        Send a msgpack encoded py-object-blob-as-msg over TCP.
+
+        If `strict_types == True` then a `MsgTypeError` will be raised on any
+        invalid msg type
+
+        '''
+        __tracebackhide__: bool = hide_tb
+
+        # XXX see `trio._sync.AsyncContextManagerMixin` for details
+        # on the `.acquire()`/`.release()` sequencing..
+        async with self._send_lock:
+
+            # NOTE: lookup the `trio.Task.context`'s var for
+            # the current `MsgCodec`.
+            codec: MsgCodec = _ctxvar_MsgCodec.get()
+
+            # XXX for ctxvar debug only!
+            # if self._codec.pld_spec != codec.pld_spec:
+            #     self._codec = codec
+            #     log.runtime(
+            #         f'Using new codec in {self}.send()\n'
+            #         f'codec: {self._codec}\n\n'
+            #         f'msg: {msg}\n'
+            #     )
+
+            if type(msg) not in msgtypes.__msg_types__:
+                if strict_types:
+                    raise _mk_send_mte(
+                        msg,
+                        codec=codec,
+                    )
+                else:
+                    log.warning(
+                        'Sending non-`Msg`-spec msg?\n\n'
+                        f'{msg}\n'
+                    )
+
+            try:
+                bytes_data: bytes = codec.encode(msg)
+            except TypeError as _err:
+                typerr = _err
+                msgtyperr: MsgTypeError = _mk_send_mte(
+                    msg,
+                    codec=codec,
+                    message=(
+                        f'IPC-msg-spec violation in\n\n'
+                        f'{pretty_struct.Struct.pformat(msg)}'
+                    ),
+                    src_type_error=typerr,
+                )
+                raise msgtyperr from typerr
+
+            # supposedly the fastest says,
+            # https://stackoverflow.com/a/54027962
+            size: bytes = struct.pack("<I", len(bytes_data))
+            return await self.stream.send_all(size + bytes_data)
+
+        # ?TODO? does it help ever to dynamically show this
+        # frame?
+        # try:
+        #     <the-above_code>
+        # except BaseException as _err:
+        #     err = _err
+        #     if not isinstance(err, MsgTypeError):
+        #         __tracebackhide__: bool = False
+        #     raise
 
     @property
-    def maddr(self) -> str:
+    def laddr(self) -> tuple[str, int]:
-        host, port = self.raddr.unwrap()
+        return self._laddr
-        return (
-            # TODO, use `ipaddress` from stdlib to handle
-            # first detecting which of `ipv4/6` before
-            # choosing the routing prefix part.
-            f'/ipv4/{host}'
 
-            f'/{self.address_type.proto_key}/{port}'
+    @property
-            # f'/{self.chan.uid[0]}'
+    def raddr(self) -> tuple[str, int]:
-            # f'/{self.cid}'
+        return self._raddr
 
-            # f'/cid={cid_head}..{cid_tail}'
+    async def recv(self) -> Any:
-            # TODO: ? not use this ^ right ?
+        return await self._aiter_pkts.asend(None)
-        )
+
+    async def drain(self) -> AsyncIterator[dict]:
+        '''
+        Drain the stream's remaining messages sent from
+        the far end until the connection is closed by
+        the peer.
+
+        '''
+        try:
+            async for msg in self._iter_packets():
+                self.drained.append(msg)
+        except TransportClosed:
+            for msg in self.drained:
+                yield msg
+
+    def __aiter__(self):
+        return self._aiter_pkts
 
     def connected(self) -> bool:
         return self.stream.socket.fileno() != -1
-
-    @classmethod
-    async def connect_to(
-        cls,
-        destaddr: TCPAddress,
-        prefix_size: int = 4,
-        codec: MsgCodec|None = None,
-        **kwargs
-    ) -> MsgpackTCPStream:
-        stream = await trio.open_tcp_stream(
-            *destaddr.unwrap(),
-            **kwargs
-        )
-        return MsgpackTCPStream(
-            stream,
-            prefix_size=prefix_size,
-            codec=codec
-        )
-
-    @classmethod
-    def get_stream_addrs(
-        cls,
-        stream: trio.SocketStream
-    ) -> tuple[
-        TCPAddress,
-        TCPAddress,
-    ]:
-        # TODO, what types are these?
-        lsockname = stream.socket.getsockname()
-        l_sockaddr: tuple[str, int] = tuple(lsockname[:2])
-        rsockname = stream.socket.getpeername()
-        r_sockaddr: tuple[str, int] = tuple(rsockname[:2])
-        return (
-            TCPAddress.from_addr(l_sockaddr),
-            TCPAddress.from_addr(r_sockaddr),
-        )

tractor/ipc/_transport.py

@@ -14,66 +14,29 @@
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 '''
-typing.Protocol based generic msg API, implement this class to add
+typing.Protocol based generic msg API, implement this class to add backends for
-backends for tractor.ipc.Channel
+tractor.ipc.Channel
 
 '''
-from __future__ import annotations
+import trio
 from typing import (
     runtime_checkable,
-    Type,
     Protocol,
-    # TypeVar,
+    TypeVar,
-    ClassVar,
-    TYPE_CHECKING,
 )
-from collections.abc import (
+from collections.abc import AsyncIterator
-    AsyncGenerator,
-    AsyncIterator,
-)
-import struct
-
-import trio
-import msgspec
-from tricycle import BufferedReceiveStream
-
-from tractor.log import get_logger
-from tractor._exceptions import (
-    MsgTypeError,
-    TransportClosed,
-    _mk_send_mte,
-    _mk_recv_mte,
-)
-from tractor.msg import (
-    _ctxvar_MsgCodec,
-    # _codec,  XXX see `self._codec` sanity/debug checks
-    MsgCodec,
-    MsgType,
-    types as msgtypes,
-    pretty_struct,
-)
-
-if TYPE_CHECKING:
-    from tractor._addr import Address
-
-log = get_logger(__name__)
-
-
-# (codec, transport)
-MsgTransportKey = tuple[str, str]
 
 
 # from tractor.msg.types import MsgType
 # ?TODO? this should be our `Union[*msgtypes.__spec__]` alias now right..?
 # => BLEH, except can't bc prots must inherit typevar or param-spec
 #   vars..
-# MsgType = TypeVar('MsgType')
+MsgType = TypeVar('MsgType')
 
 
 @runtime_checkable
-class MsgTransport(Protocol):
+class MsgTransport(Protocol[MsgType]):
 #
-# class MsgTransport(Protocol[MsgType]):
 # ^-TODO-^ consider using a generic def and indexing with our
 # eventual msg definition/types?
 # - https://docs.python.org/3/library/typing.html#typing.Protocol
@@ -81,8 +44,8 @@ class MsgTransport(Protocol):
     stream: trio.abc.Stream
     drained: list[MsgType]
 
-    address_type: ClassVar[Type[Address]]
+    def __init__(self, stream: trio.abc.Stream) -> None:
-    codec_key: ClassVar[str]
+        ...
 
     # XXX: should this instead be called `.sendall()`?
     async def send(self, msg: MsgType) -> None:
@@ -102,413 +65,10 @@ class MsgTransport(Protocol):
     def drain(self) -> AsyncIterator[dict]:
         ...
 
-    @classmethod
-    def key(cls) -> MsgTransportKey:
-        return (
-            cls.codec_key,
-            cls.address_type.proto_key,
-        )
-
     @property
-    def laddr(self) -> Address:
+    def laddr(self) -> tuple[str, int]:
         ...
 
     @property
-    def raddr(self) -> Address:
+    def raddr(self) -> tuple[str, int]:
         ...
-
-    @property
-    def maddr(self) -> str:
-        ...
-
-    @classmethod
-    async def connect_to(
-        cls,
-        addr: Address,
-        **kwargs
-    ) -> MsgTransport:
-        ...
-
-    @classmethod
-    def get_stream_addrs(
-        cls,
-        stream: trio.abc.Stream
-    ) -> tuple[
-        Address,  # local
-        Address   # remote
-    ]:
-        '''
-        Return the transport protocol's address pair for the local
-        and remote-peer side.
-
-        '''
-        ...
-
-    # TODO, such that all `.raddr`s for each `SocketStream` are
-    # delivered?
-    # -[ ] move `.open_listener()` here and internally track the
-    #     listener set, per address?
-    # def get_peers(
-    #     self,
-    # ) -> list[Address]:
-    #     ...
-
-
-
-class MsgpackTransport(MsgTransport):
-
-    # TODO: better naming for this?
-    # -[ ] check how libp2p does naming for such things?
-    codec_key: str = 'msgpack'
-
-    def __init__(
-        self,
-        stream: trio.abc.Stream,
-        prefix_size: int = 4,
-
-        # XXX optionally provided codec pair for `msgspec`:
-        # https://jcristharif.com/msgspec/extending.html#mapping-to-from-native-types
-        #
-        # TODO: define this as a `Codec` struct which can be
-        # overriden dynamically by the application/runtime?
-        codec: MsgCodec = None,
-
-    ) -> None:
-        self.stream = stream
-        (
-            self._laddr,
-            self._raddr,
-        ) = self.get_stream_addrs(stream)
-
-        # create read loop instance
-        self._aiter_pkts = self._iter_packets()
-        self._send_lock = trio.StrictFIFOLock()
-
-        # public i guess?
-        self.drained: list[dict] = []
-
-        self.recv_stream = BufferedReceiveStream(
-            transport_stream=stream
-        )
-        self.prefix_size = prefix_size
-
-        # allow for custom IPC msg interchange format
-        # dynamic override Bo
-        self._task = trio.lowlevel.current_task()
-
-        # XXX for ctxvar debug only!
-        # self._codec: MsgCodec = (
-        #     codec
-        #     or
-        #     _codec._ctxvar_MsgCodec.get()
-        # )
-
-    async def _iter_packets(self) -> AsyncGenerator[dict, None]:
-        '''
-        Yield `bytes`-blob decoded packets from the underlying TCP
-        stream using the current task's `MsgCodec`.
-
-        This is a streaming routine implemented as an async generator
-        func (which was the original design, but could be changed?)
-        and is allocated by a `.__call__()` inside `.__init__()` where
-        it is assigned to the `._aiter_pkts` attr.
-
-        '''
-        decodes_failed: int = 0
-
-        tpt_name: str = f'{type(self).__name__!r}'
-        while True:
-            try:
-                header: bytes = await self.recv_stream.receive_exactly(4)
-            except (
-                ValueError,
-                ConnectionResetError,
-
-                # not sure entirely why we need this but without it we
-                # seem to be getting racy failures here on
-                # arbiter/registry name subs..
-                trio.BrokenResourceError,
-
-            ) as trans_err:
-
-                loglevel = 'transport'
-                match trans_err:
-                    # case (
-                    #     ConnectionResetError()
-                    # ):
-                    #     loglevel = 'transport'
-
-                    # peer actor (graceful??) TCP EOF but `tricycle`
-                    # seems to raise a 0-bytes-read?
-                    case ValueError() if (
-                        'unclean EOF' in trans_err.args[0]
-                    ):
-                        pass
-
-                    # peer actor (task) prolly shutdown quickly due
-                    # to cancellation
-                    case trio.BrokenResourceError() if (
-                        'Connection reset by peer' in trans_err.args[0]
-                    ):
-                        pass
-
-                    # unless the disconnect condition falls under "a
-                    # normal operation breakage" we usualy console warn
-                    # about it.
-                    case _:
-                        loglevel: str = 'warning'
-
-
-                raise TransportClosed(
-                    message=(
-                        f'{tpt_name} already closed by peer\n'
-                    ),
-                    src_exc=trans_err,
-                    loglevel=loglevel,
-                ) from trans_err
-
-            # XXX definitely can happen if transport is closed
-            # manually by another `trio.lowlevel.Task` in the
-            # same actor; we use this in some simulated fault
-            # testing for ex, but generally should never happen
-            # under normal operation!
-            #
-            # NOTE: as such we always re-raise this error from the
-            #       RPC msg loop!
-            except trio.ClosedResourceError as cre:
-                closure_err = cre
-
-                raise TransportClosed(
-                    message=(
-                        f'{tpt_name} was already closed locally ?\n'
-                    ),
-                    src_exc=closure_err,
-                    loglevel='error',
-                    raise_on_report=(
-                        'another task closed this fd' in closure_err.args
-                    ),
-                ) from closure_err
-
-            # graceful TCP EOF disconnect
-            if header == b'':
-                raise TransportClosed(
-                    message=(
-                        f'{tpt_name} already gracefully closed\n'
-                    ),
-                    loglevel='transport',
-                )
-
-            size: int
-            size, = struct.unpack("<I", header)
-
-            log.transport(f'received header {size}')  # type: ignore
-            msg_bytes: bytes = await self.recv_stream.receive_exactly(size)
-
-            log.transport(f"received {msg_bytes}")  # type: ignore
-            try:
-                # NOTE: lookup the `trio.Task.context`'s var for
-                # the current `MsgCodec`.
-                codec: MsgCodec = _ctxvar_MsgCodec.get()
-
-                # XXX for ctxvar debug only!
-                # if self._codec.pld_spec != codec.pld_spec:
-                #     assert (
-                #         task := trio.lowlevel.current_task()
-                #     ) is not self._task
-                #     self._task = task
-                #     self._codec = codec
-                #     log.runtime(
-                #         f'Using new codec in {self}.recv()\n'
-                #         f'codec: {self._codec}\n\n'
-                #         f'msg_bytes: {msg_bytes}\n'
-                #     )
-                yield codec.decode(msg_bytes)
-
-            # XXX NOTE: since the below error derives from
-            # `DecodeError` we need to catch is specially
-            # and always raise such that spec violations
-            # are never allowed to be caught silently!
-            except msgspec.ValidationError as verr:
-                msgtyperr: MsgTypeError = _mk_recv_mte(
-                    msg=msg_bytes,
-                    codec=codec,
-                    src_validation_error=verr,
-                )
-                # XXX deliver up to `Channel.recv()` where
-                # a re-raise and `Error`-pack can inject the far
-                # end actor `.uid`.
-                yield msgtyperr
-
-            except (
-                msgspec.DecodeError,
-                UnicodeDecodeError,
-            ):
-                if decodes_failed < 4:
-                    # ignore decoding errors for now and assume they have to
-                    # do with a channel drop - hope that receiving from the
-                    # channel will raise an expected error and bubble up.
-                    try:
-                        msg_str: str|bytes = msg_bytes.decode()
-                    except UnicodeDecodeError:
-                        msg_str = msg_bytes
-
-                    log.exception(
-                        'Failed to decode msg?\n'
-                        f'{codec}\n\n'
-                        'Rxed bytes from wire:\n\n'
-                        f'{msg_str!r}\n'
-                    )
-                    decodes_failed += 1
-                else:
-                    raise
-
-    async def send(
-        self,
-        msg: msgtypes.MsgType,
-
-        strict_types: bool = True,
-        hide_tb: bool = True,
-
-    ) -> None:
-        '''
-        Send a msgpack encoded py-object-blob-as-msg over TCP.
-
-        If `strict_types == True` then a `MsgTypeError` will be raised on any
-        invalid msg type
-
-        '''
-        __tracebackhide__: bool = hide_tb
-
-        # XXX see `trio._sync.AsyncContextManagerMixin` for details
-        # on the `.acquire()`/`.release()` sequencing..
-        async with self._send_lock:
-
-            # NOTE: lookup the `trio.Task.context`'s var for
-            # the current `MsgCodec`.
-            codec: MsgCodec = _ctxvar_MsgCodec.get()
-
-            # XXX for ctxvar debug only!
-            # if self._codec.pld_spec != codec.pld_spec:
-            #     self._codec = codec
-            #     log.runtime(
-            #         f'Using new codec in {self}.send()\n'
-            #         f'codec: {self._codec}\n\n'
-            #         f'msg: {msg}\n'
-            #     )
-
-            if type(msg) not in msgtypes.__msg_types__:
-                if strict_types:
-                    raise _mk_send_mte(
-                        msg,
-                        codec=codec,
-                    )
-                else:
-                    log.warning(
-                        'Sending non-`Msg`-spec msg?\n\n'
-                        f'{msg}\n'
-                    )
-
-            try:
-                bytes_data: bytes = codec.encode(msg)
-            except TypeError as _err:
-                typerr = _err
-                msgtyperr: MsgTypeError = _mk_send_mte(
-                    msg,
-                    codec=codec,
-                    message=(
-                        f'IPC-msg-spec violation in\n\n'
-                        f'{pretty_struct.Struct.pformat(msg)}'
-                    ),
-                    src_type_error=typerr,
-                )
-                raise msgtyperr from typerr
-
-            # supposedly the fastest says,
-            # https://stackoverflow.com/a/54027962
-            size: bytes = struct.pack("<I", len(bytes_data))
-            try:
-                return await self.stream.send_all(size + bytes_data)
-            except (
-                trio.BrokenResourceError,
-            ) as bre:
-                trans_err = bre
-                tpt_name: str = f'{type(self).__name__!r}'
-                match trans_err:
-                    case trio.BrokenResourceError() if (
-                        '[Errno 32] Broken pipe' in trans_err.args[0]
-                        # ^XXX, specifc to UDS transport and its,
-                        # well, "speediness".. XD
-                        # |_ likely todo with races related to how fast
-                        #    the socket is setup/torn-down on linux
-                        #    as it pertains to rando pings from the
-                        #    `.discovery` subsys and protos.
-                    ):
-                        raise TransportClosed.from_src_exc(
-                            message=(
-                                f'{tpt_name} already closed by peer\n'
-                            ),
-                            body=f'{self}\n',
-                            src_exc=trans_err,
-                            raise_on_report=True,
-                            loglevel='transport',
-                        ) from bre
-
-                    # unless the disconnect condition falls under "a
-                    # normal operation breakage" we usualy console warn
-                    # about it.
-                    case _:
-                        log.exception(
-                            '{tpt_name} layer failed pre-send ??\n'
-                        )
-                        raise trans_err
-
-        # ?TODO? does it help ever to dynamically show this
-        # frame?
-        # try:
-        #     <the-above_code>
-        # except BaseException as _err:
-        #     err = _err
-        #     if not isinstance(err, MsgTypeError):
-        #         __tracebackhide__: bool = False
-        #     raise
-
-    async def recv(self) -> msgtypes.MsgType:
-        return await self._aiter_pkts.asend(None)
-
-    async def drain(self) -> AsyncIterator[dict]:
-        '''
-        Drain the stream's remaining messages sent from
-        the far end until the connection is closed by
-        the peer.
-
-        '''
-        try:
-            async for msg in self._iter_packets():
-                self.drained.append(msg)
-        except TransportClosed:
-            for msg in self.drained:
-                yield msg
-
-    def __aiter__(self):
-        return self._aiter_pkts
-
-    @property
-    def laddr(self) -> Address:
-        return self._laddr
-
-    @property
-    def raddr(self) -> Address:
-        return self._raddr
-
-    def pformat(self) -> str:
-        return (
-            f'<{type(self).__name__}(\n'
-            f' |_peers: 2\n'
-            f'   laddr: {self._laddr}\n'
-            f'   raddr: {self._raddr}\n'
-            # f'\n'
-            f' |_task: {self._task}\n'
-            f')>\n'
-        )
-
-    __repr__ = __str__ = pformat

tractor/ipc/_types.py

@@ -1,123 +0,0 @@
-# tractor: structured concurrent "actors".
-# Copyright 2018-eternity Tyler Goodlet.
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Affero General Public License for more details.
-
-# You should have received a copy of the GNU Affero General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-'''
-IPC subsys type-lookup helpers?
-
-'''
-from typing import (
-    Type,
-    # TYPE_CHECKING,
-)
-
-import trio
-import socket
-
-from tractor.ipc._transport import (
-    MsgTransportKey,
-    MsgTransport
-)
-from tractor.ipc._tcp import (
-    TCPAddress,
-    MsgpackTCPStream,
-)
-from tractor.ipc._uds import (
-    UDSAddress,
-    MsgpackUDSStream,
-)
-
-# if TYPE_CHECKING:
-#     from tractor._addr import Address
-
-
-Address = TCPAddress|UDSAddress
-
-# manually updated list of all supported msg transport types
-_msg_transports = [
-    MsgpackTCPStream,
-    MsgpackUDSStream
-]
-
-
-# convert a MsgTransportKey to the corresponding transport type
-_key_to_transport: dict[
-    MsgTransportKey,
-    Type[MsgTransport],
-] = {
-    ('msgpack', 'tcp'): MsgpackTCPStream,
-    ('msgpack', 'uds'): MsgpackUDSStream,
-}
-
-# convert an Address wrapper to its corresponding transport type
-_addr_to_transport: dict[
-    Type[TCPAddress|UDSAddress],
-    Type[MsgTransport]
-] = {
-    TCPAddress: MsgpackTCPStream,
-    UDSAddress: MsgpackUDSStream,
-}
-
-
-def transport_from_addr(
-    addr: Address,
-    codec_key: str = 'msgpack',
-) -> Type[MsgTransport]:
-    '''
-    Given a destination address and a desired codec, find the
-    corresponding `MsgTransport` type.
-
-    '''
-    try:
-        return _addr_to_transport[type(addr)]
-
-    except KeyError:
-        raise NotImplementedError(
-            f'No known transport for address {repr(addr)}'
-        )
-
-
-def transport_from_stream(
-    stream: trio.abc.Stream,
-    codec_key: str = 'msgpack'
-) -> Type[MsgTransport]:
-    '''
-    Given an arbitrary `trio.abc.Stream` and a desired codec,
-    find the corresponding `MsgTransport` type.
-
-    '''
-    transport = None
-    if isinstance(stream, trio.SocketStream):
-        sock: socket.socket = stream.socket
-        match sock.family:
-            case socket.AF_INET | socket.AF_INET6:
-                transport = 'tcp'
-
-            case socket.AF_UNIX:
-                transport = 'uds'
-
-            case _:
-                raise NotImplementedError(
-                    f'Unsupported socket family: {sock.family}'
-                )
-
-    if not transport:
-        raise NotImplementedError(
-            f'Could not figure out transport type for stream type {type(stream)}'
-        )
-
-    key = (codec_key, transport)
-
-    return _key_to_transport[key]

tractor/ipc/_uds.py

@@ -1,422 +0,0 @@
-# tractor: structured concurrent "actors".
-# Copyright 2018-eternity Tyler Goodlet.
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Affero General Public License for more details.
-
-# You should have received a copy of the GNU Affero General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-'''
-Unix Domain Socket implementation of tractor.ipc._transport.MsgTransport protocol 
-
-'''
-from __future__ import annotations
-from pathlib import Path
-import os
-from socket import (
-    AF_UNIX,
-    SOCK_STREAM,
-    SO_PASSCRED,
-    SO_PEERCRED,
-    SOL_SOCKET,
-)
-import struct
-from typing import (
-    TYPE_CHECKING,
-    ClassVar,
-)
-
-import msgspec
-import trio
-from trio import (
-    socket,
-    SocketListener,
-)
-from trio._highlevel_open_unix_stream import (
-    close_on_error,
-    has_unix,
-)
-
-from tractor.msg import MsgCodec
-from tractor.log import get_logger
-from tractor.ipc._transport import (
-    MsgpackTransport,
-)
-from .._state import (
-    get_rt_dir,
-    current_actor,
-    is_root_process,
-)
-
-if TYPE_CHECKING:
-    from ._runtime import Actor
-
-
-log = get_logger(__name__)
-
-
-def unwrap_sockpath(
-    sockpath: Path,
-) -> tuple[Path, Path]:
-    return (
-        sockpath.parent,
-        sockpath.name,
-    )
-
-
-class UDSAddress(
-    msgspec.Struct,
-    frozen=True,
-):
-    filedir: str|Path|None
-    filename: str|Path
-    maybe_pid: int|None = None
-
-    # TODO, maybe we should use better field and value
-    # -[x] really this is a `.protocol_key` not a "name" of anything.
-    # -[ ] consider a 'unix' proto-key instead?
-    # -[ ] need to check what other mult-transport frameworks do
-    #     like zmq, nng, uri-spec et al!
-    proto_key: ClassVar[str] = 'uds'
-    unwrapped_type: ClassVar[type] = tuple[str, int]
-    def_bindspace: ClassVar[Path] = get_rt_dir()
-
-    @property
-    def bindspace(self) -> Path:
-        '''
-        We replicate the "ip-set-of-hosts" part of a UDS socket as
-        just the sub-directory in which we allocate socket files.
-
-        '''
-        return (
-            self.filedir
-            or
-            self.def_bindspace
-            # or
-            # get_rt_dir()
-        )
-
-    @property
-    def sockpath(self) -> Path:
-        return self.bindspace / self.filename
-
-    @property
-    def is_valid(self) -> bool:
-        '''
-        We block socket files not allocated under the runtime subdir.
-
-        '''
-        return self.bindspace in self.sockpath.parents
-
-    @classmethod
-    def from_addr(
-        cls,
-        addr: (
-            tuple[Path|str, Path|str]|Path|str
-        ),
-    ) -> UDSAddress:
-        match addr:
-            case tuple()|list():
-                filedir = Path(addr[0])
-                filename = Path(addr[1])
-                return UDSAddress(
-                    filedir=filedir,
-                    filename=filename,
-                    # maybe_pid=pid,
-                )
-            # NOTE, in case we ever decide to just `.unwrap()`
-            # to a `Path|str`?
-            case str()|Path():
-                sockpath: Path = Path(addr)
-                return UDSAddress(*unwrap_sockpath(sockpath))
-            case _:
-                # import pdbp; pdbp.set_trace()
-                raise TypeError(
-                    f'Bad unwrapped-address for {cls} !\n'
-                    f'{addr!r}\n'
-                )
-
-    def unwrap(self) -> tuple[str, int]:
-        # XXX NOTE, since this gets passed DIRECTLY to
-        # `.ipc._uds.open_unix_socket_w_passcred()`
-        return (
-            str(self.filedir),
-            str(self.filename),
-        )
-
-    @classmethod
-    def get_random(
-        cls,
-        bindspace: Path|None = None,  # default netns
-    ) -> UDSAddress:
-
-        filedir: Path = bindspace or cls.def_bindspace
-        pid: int = os.getpid()
-        actor: Actor|None = current_actor(
-            err_on_no_runtime=False,
-        )
-        if actor:
-            sockname: str = '::'.join(actor.uid) + f'@{pid}'
-        else:
-            prefix: str = '<unknown-actor>'
-            if is_root_process():
-                prefix: str = 'root'
-            sockname: str = f'{prefix}@{pid}'
-
-        sockpath: Path = Path(f'{sockname}.sock')
-        return UDSAddress(
-            filedir=filedir,
-            filename=sockpath,
-            maybe_pid=pid,
-        )
-
-    @classmethod
-    def get_root(cls) -> UDSAddress:
-        def_uds_filename: Path = 'registry@1616.sock'
-        return UDSAddress(
-            filedir=cls.def_bindspace,
-            filename=def_uds_filename,
-            # maybe_pid=1616,
-        )
-
-    # ?TODO, maybe we should just our .msg.pretty_struct.Struct` for
-    # this instead?
-    # -[ ] is it too "multi-line"y tho?
-    #      the compact tuple/.unwrapped() form is simple enough?
-    #
-    def __repr__(self) -> str:
-        if not (pid := self.maybe_pid):
-            pid: str = '<unknown-peer-pid>'
-
-        body: str = (
-            f'({self.filedir}, {self.filename}, {pid})'
-        )
-        return (
-            f'{type(self).__name__}'
-            f'['
-            f'{body}'
-            f']'
-        )
-
-
-async def start_listener(
-    addr: UDSAddress,
-    **kwargs,
-) -> SocketListener:
-    # sock = addr._sock = socket.socket(
-    sock = socket.socket(
-        socket.AF_UNIX,
-        socket.SOCK_STREAM
-    )
-    log.info(
-        f'Attempting to bind UDS socket\n'
-        f'>[\n'
-        f'|_{addr}\n'
-    )
-
-    bindpath: Path = addr.sockpath
-    try:
-        await sock.bind(str(bindpath))
-    except (
-        FileNotFoundError,
-    ) as fdne:
-        raise ConnectionError(
-            f'Bad UDS socket-filepath-as-address ??\n'
-            f'{addr}\n'
-            f' |_sockpath: {addr.sockpath}\n'
-        ) from fdne
-
-    sock.listen(1)
-    log.info(
-        f'Listening on UDS socket\n'
-        f'[>\n'
-        f' |_{addr}\n'
-    )
-    return SocketListener(sock)
-
-
-def close_listener(
-    addr: UDSAddress,
-    lstnr: SocketListener,
-) -> None:
-    '''
-    Close and remove the listening unix socket's path.
-
-    '''
-    lstnr.socket.close()
-    os.unlink(addr.sockpath)
-
-
-async def open_unix_socket_w_passcred(
-    filename: str|bytes|os.PathLike[str]|os.PathLike[bytes],
-) -> trio.SocketStream:
-    '''
-    Literally the exact same as `trio.open_unix_socket()` except we set the additiona
-    `socket.SO_PASSCRED` option to ensure the server side (the process calling `accept()`)
-    can extract the connecting peer's credentials, namely OS specific process
-    related IDs.
-
-    See this SO for "why" the extra opts,
-    - https://stackoverflow.com/a/7982749
-
-    '''
-    if not has_unix:
-        raise RuntimeError("Unix sockets are not supported on this platform")
-
-    # much more simplified logic vs tcp sockets - one socket type and only one
-    # possible location to connect to
-    sock = trio.socket.socket(AF_UNIX, SOCK_STREAM)
-    sock.setsockopt(SOL_SOCKET, SO_PASSCRED, 1)
-    with close_on_error(sock):
-        await sock.connect(os.fspath(filename))
-
-    return trio.SocketStream(sock)
-
-
-def get_peer_info(sock: trio.socket.socket) -> tuple[
-    int,  # pid
-    int,  # uid
-    int,  # guid
-]:
-    '''
-    Deliver the connecting peer's "credentials"-info as defined in
-    a very Linux specific way..
-
-    For more deats see,
-    - `man accept`,
-    - `man unix`,
-
-    this great online guide to all things sockets,
-    - https://beej.us/guide/bgnet/html/split-wide/man-pages.html#setsockoptman
-
-    AND this **wonderful SO answer**
-    - https://stackoverflow.com/a/7982749
-
-    '''
-    creds: bytes = sock.getsockopt(
-        SOL_SOCKET,
-        SO_PEERCRED,
-        struct.calcsize('3i')
-    )
-    # i.e a tuple of the fields,
-    # pid: int, "process"
-    # uid: int, "user"
-    # gid: int, "group"
-    return struct.unpack('3i', creds)
-
-
-class MsgpackUDSStream(MsgpackTransport):
-    '''
-    A `trio.SocketStream` around a Unix-Domain-Socket transport
-    delivering `msgpack` encoded msgs using the `msgspec` codec lib.
-
-    '''
-    address_type = UDSAddress
-    layer_key: int = 4
-
-    @property
-    def maddr(self) -> str:
-        if not self.raddr:
-            return '<unknown-peer>'
-
-        filepath: Path = Path(self.raddr.unwrap()[0])
-        return (
-            f'/{self.address_type.proto_key}/{filepath}'
-            # f'/{self.chan.uid[0]}'
-            # f'/{self.cid}'
-
-            # f'/cid={cid_head}..{cid_tail}'
-            # TODO: ? not use this ^ right ?
-        )
-
-    def connected(self) -> bool:
-        return self.stream.socket.fileno() != -1
-
-    @classmethod
-    async def connect_to(
-        cls,
-        addr: UDSAddress,
-        prefix_size: int = 4,
-        codec: MsgCodec|None = None,
-        **kwargs
-    ) -> MsgpackUDSStream:
-
-
-        sockpath: Path = addr.sockpath
-        #
-        # ^XXX NOTE, we don't provide any out-of-band `.pid` info
-        # (like, over the socket as extra msgs) since the (augmented)
-        # `.setsockopt()` call tells the OS provide it; the client
-        # pid can then be read on server/listen() side via
-        # `get_peer_info()` above.
-        try:
-            stream = await open_unix_socket_w_passcred(
-                str(sockpath),
-                **kwargs
-            )
-        except (
-            FileNotFoundError,
-        ) as fdne:
-            raise ConnectionError(
-                f'Bad UDS socket-filepath-as-address ??\n'
-                f'{addr}\n'
-                f' |_sockpath: {sockpath}\n'
-            ) from fdne
-
-        stream = MsgpackUDSStream(
-            stream,
-            prefix_size=prefix_size,
-            codec=codec
-        )
-        stream._raddr = addr
-        return stream
-
-    @classmethod
-    def get_stream_addrs(
-        cls,
-        stream: trio.SocketStream
-    ) -> tuple[
-        Path,
-        int,
-    ]:
-        sock: trio.socket.socket = stream.socket
-
-        # NOTE XXX, it's unclear why one or the other ends up being
-        # `bytes` versus the socket-file-path, i presume it's
-        # something to do with who is the server (called `.listen()`)?
-        # maybe could be better implemented using another info-query
-        # on the socket like,
-        # https://beej.us/guide/bgnet/html/split-wide/system-calls-or-bust.html#gethostnamewho-am-i
-        sockname: str|bytes = sock.getsockname()
-        # https://beej.us/guide/bgnet/html/split-wide/system-calls-or-bust.html#getpeernamewho-are-you
-        peername: str|bytes = sock.getpeername()
-        match (peername, sockname):
-            case (str(), bytes()):
-                sock_path: Path = Path(peername)
-            case (bytes(), str()):
-                sock_path: Path = Path(sockname)
-        (
-            peer_pid,
-            _,
-            _,
-        ) = get_peer_info(sock)
-
-        filedir, filename = unwrap_sockpath(sock_path)
-        laddr = UDSAddress(
-            filedir=filedir,
-            filename=filename,
-            maybe_pid=os.getpid(),
-        )
-        raddr = UDSAddress(
-            filedir=filedir,
-            filename=filename,
-            maybe_pid=peer_pid
-        )
-        return (laddr, raddr)

tractor/linux/eventfd.py

@@ -163,17 +163,10 @@ class EventFD:
         async with self._read_lock:
             self._cscope = trio.CancelScope()
             with self._cscope:
-                try:
+                return await trio.to_thread.run_sync(
-                    return await trio.to_thread.run_sync(
+                    read_eventfd, self._fd,
-                        read_eventfd, self._fd,
+                    abandon_on_cancel=True
-                        abandon_on_cancel=True
+                )
-                    )
-
-                except OSError as e:
-                    if e.errno != errno.EBADF:
-                        raise
-
-                    raise trio.BrokenResourceError
 
             if self._cscope.cancelled_caught:
                 raise EFDReadCancelled

tractor/msg/_codec.py

@@ -39,11 +39,13 @@ from contextvars import (
 )
 import textwrap
 from typing import (
-    TYPE_CHECKING,
     Any,
-    Type,
-    Union,
     Callable,
+    Protocol,
+    Type,
+    TYPE_CHECKING,
+    TypeVar,
+    Union,
 )
 from types import ModuleType
 
@@ -52,13 +54,6 @@ from msgspec import (
     msgpack,
     Raw,
 )
-from msgspec.inspect import (
-    CustomType,
-    UnionType,
-    SetType,
-    ListType,
-    TupleType
-)
 # TODO: see notes below from @mikenerone..
 # from tricycle import TreeVar
 
@@ -86,7 +81,7 @@ class MsgDec(Struct):
 
     '''
     _dec: msgpack.Decoder
-    _ext_types_boxes: dict[Type, Struct] = {}
+    # _ext_types_box: Struct|None = None
 
     @property
     def dec(self) -> msgpack.Decoder:
@@ -231,8 +226,6 @@ def mk_dec(
             f'ext_types = {ext_types!r}\n'
         )
 
-    _boxed_structs: dict[Type, Struct] = {}
-
     if dec_hook:
         if ext_types is None:
             raise TypeError(
@@ -244,15 +237,17 @@ def mk_dec(
                 f'ext_types = {ext_types!r}\n'
             )
 
-        if len(ext_types) > 1:
+        # XXX, i *thought* we would require a boxing struct as per docs,
-            _boxed_structs = mk_boxed_ext_structs(ext_types)
+        # https://jcristharif.com/msgspec/extending.html#mapping-to-from-native-types
-            ext_types = [
+        # |_ see comment,
-                etype
+        #  > Note that typed deserialization is required for
-                for etype in ext_types
+        #  > successful roundtripping here, so we pass `MyMessage` to
-                if etype not in _boxed_structs
+        #  > `Decoder`.
-            ]
+        #
-            ext_types += list(_boxed_structs.values())
+        # BUT, turns out as long as you spec a union with `Raw` it
-
+        # will work? kk B)
+        #
+        # maybe_box_struct = mk_boxed_ext_struct(ext_types)
         spec = Raw | Union[*ext_types]
 
     return MsgDec(
@@ -260,26 +255,29 @@ def mk_dec(
             type=spec,  # like `MsgType[Any]`
             dec_hook=dec_hook,
         ),
-        _ext_types_boxes=_boxed_structs
     )
 
 
-def mk_boxed_ext_structs(
+# TODO? remove since didn't end up needing this?
+def mk_boxed_ext_struct(
     ext_types: list[Type],
-) -> dict[Type, Struct]:
+) -> Struct:
-    box_types: dict[Type, Struct] = {}
+    # NOTE, originally was to wrap non-msgpack-supported "extension
-    for ext_type in ext_types:
+    # types" in a field-typed boxing struct, see notes around the
-        info = msgspec.inspect.type_info(ext_type)
+    # `dec_hook()` branch in `mk_dec()`.
-        if isinstance(info, CustomType):
+    ext_types_union = Union[*ext_types]
-            box_types[ext_type] = msgspec.defstruct(
+    repr_ext_types_union: str = (
-                f'Box{ext_type.__name__}',
+        str(ext_types_union)
-                tag=True,
+        or
-                fields=[
+        "|".join(ext_types)
-                    ('inner', ext_type),
+    )
-                ],
+    BoxedExtType = msgspec.defstruct(
-            )
+        f'BoxedExts[{repr_ext_types_union}]',
-
+        fields=[
-    return box_types
+            ('boxed', ext_types_union),
+        ],
+    )
+    return BoxedExtType
 
 
 def unpack_spec_types(
@@ -380,7 +378,7 @@ class MsgCodec(Struct):
     _dec: msgpack.Decoder
     _pld_spec: Type[Struct]|Raw|Any
 
-    _ext_types_boxes: dict[Type, Struct] = {}
+    # _ext_types_box: Struct|None = None
 
     def __repr__(self) -> str:
         speclines: str = textwrap.indent(
@@ -467,29 +465,45 @@ class MsgCodec(Struct):
 
         '''
         __tracebackhide__: bool = hide_tb
+        if use_buf:
+            self._enc.encode_into(py_obj, self._buf)
+            return self._buf
 
-        try:
+        return self._enc.encode(py_obj)
+        # try:
+        #     return self._enc.encode(py_obj)
+        # except TypeError as typerr:
+        #     typerr.add_note(
+        #         '|_src error from `msgspec`'
+        #         # f'|_{self._enc.encode!r}'
+        #     )
+        #     raise typerr
 
-            box: Struct|None = self._ext_types_boxes.get(type(py_obj), None)
+        # TODO! REMOVE once i'm confident we won't ever need it!
-            if (
+        #
-                as_ext_type
+        # box: Struct = self._ext_types_box
-                or
+        # if (
-                box
+        #     as_ext_type
-            ):
+        #     or
-                py_obj = box(inner=py_obj)
+        #     (
-
+        #         # XXX NOTE, auto-detect if the input type
-            if use_buf:
+        #         box
-                self._enc.encode_into(py_obj, self._buf)
+        #         and
-                return self._buf
+        #         (ext_types := unpack_spec_types(
-
+        #             spec=box.__annotations__['boxed'])
-            return self._enc.encode(py_obj)
+        #         )
-
+        #     )
-        except TypeError as typerr:
+        # ):
-            typerr.add_note(
+        #     match py_obj:
-                '|_src error from `msgspec`'
+        #         # case PayloadMsg(pld=pld) if (
-                # f'|_{self._enc.encode!r}'
+        #         #     type(pld) in ext_types
-            )
+        #         # ):
-            raise typerr
+        #         #     py_obj.pld = box(boxed=py_obj)
+        #         #     breakpoint()
+        #         case _ if (
+        #             type(py_obj) in ext_types
+        #         ):
+        #             py_obj = box(boxed=py_obj)
 
     @property
     def dec(self) -> msgpack.Decoder:
@@ -551,6 +565,11 @@ def mk_codec(
     enc_hook: Callable|None = None,
     ext_types: list[Type]|None = None,
 
+    # optionally provided msg-decoder from which we pull its,
+    # |_.dec_hook()
+    # |_.type
+    ext_dec: MsgDec|None = None
+    #
     # ?TODO? other params we might want to support
     # Encoder:
     # write_buffer_size=write_buffer_size,
@@ -578,6 +597,12 @@ def mk_codec(
             )
 
     dec_hook: Callable|None = None
+    if ext_dec:
+        dec: msgspec.Decoder = ext_dec.dec
+        dec_hook = dec.dec_hook
+        pld_spec |= dec.type
+        if ext_types:
+            pld_spec |= Union[*ext_types]
 
     # (manually) generate a msg-spec (how appropes) for all relevant
     # payload-boxing-struct-msg-types, parameterizing the
@@ -605,16 +630,10 @@ def mk_codec(
     enc = msgpack.Encoder(
        enc_hook=enc_hook,
     )
-
-    boxes = {}
-    if ext_types and len(ext_types) > 1:
-        boxes = mk_boxed_ext_structs(ext_types)
-
     codec = MsgCodec(
         _enc=enc,
         _dec=dec,
         _pld_spec=pld_spec,
-        _ext_types_boxes=boxes
     )
     # sanity on expected backend support
     assert codec.lib.__name__ == libname
@@ -790,298 +809,78 @@ def limit_msg_spec(
     assert curr_codec is current_codec()
 
 
-'''
+# XXX: msgspec won't allow this with non-struct custom types
-Encoder / Decoder generic hook factory
+# like `NamespacePath`!@!
+# @cm
+# def extend_msg_spec(
+#     payload_spec: Union[Type[Struct]],
 
-'''
+# ) -> MsgCodec:
+#     '''
+#     Extend the current `MsgCodec.pld_spec` (type set) by extending
+#     the payload spec to **include** the types specified by
+#     `payload_spec`.
+
+#     '''
+#     codec: MsgCodec = current_codec()
+#     pld_spec: Union[Type] = codec.pld_spec
+#     extended_spec: Union[Type] = pld_spec|payload_spec
+
+#     with limit_msg_spec(payload_types=extended_spec) as ext_codec:
+#         # import pdbp; pdbp.set_trace()
+#         assert ext_codec.pld_spec == extended_spec
+#         yield ext_codec
+#
+# ^-TODO-^ is it impossible to make something like this orr!?
+
+# TODO: make an auto-custom hook generator from a set of input custom
+# types?
+# -[ ] below is a proto design using a `TypeCodec` idea?
+#
+# type var for the expected interchange-lib's
+# IPC-transport type when not available as a built-in
+# serialization output.
+WireT = TypeVar('WireT')
 
 
-# builtins we can have in same pld_spec as custom types
+# TODO: some kinda (decorator) API for built-in subtypes
-default_builtins = (
+# that builds this implicitly by inspecting the `mro()`?
-    None,
+class TypeCodec(Protocol):
-    bool,
-    int,
-    float,
-    bytes,
-    list
-)
-
-
-# spec definition type
-TypeSpec = (
-    Type |
-    Union[Type] |
-    list[Type] |
-    tuple[Type] |
-    set[Type]
-)
-
-
-class TypeCodec:
     '''
-    This class describes a way of encoding to or decoding from a "wire type",
+    A per-custom-type wire-transport serialization translator
-    objects that have `encode_fn` and `decode_fn` can be used with
+    description type.
-    `.encode/.decode`.
 
     '''
+    src_type: Type
+    wire_type: WireT
 
-    def __init__(
+    def encode(obj: Type) -> WireT:
-        self,
+        ...
-        wire_type: Type,
-        decode_fn: str,
-        encode_fn: str = 'encode',
-    ):
-        self._encode_fn: str = encode_fn
-        self._decode_fn: str = decode_fn
-        self._wire_type: Type = wire_type
 
-    def __repr__(self) -> str:
+    def decode(
-        return (
+        obj_type: Type[WireT],
-            f'{type(self).__name__}('
+        obj: WireT,
-            f'{self._encode_fn}, '
+    ) -> Type:
-            f'{self._decode_fn}) '
+        ...
-            f'-> {self._wire_type}'
-        )
-
-    @property
-    def encode_fn(self) -> str:
-        return self._encode_fn
-
-    @property
-    def decode_fn(self) -> str:
-        return self._decode_fn
-
-    @property
-    def wire_type(self) -> str:
-        return self._wire_type
-
-    def is_type_compat(self, obj: any) -> bool:
-        return (
-            hasattr(obj, self._encode_fn)
-            and
-            hasattr(obj, self._decode_fn)
-        )
-
-    def encode(self, obj: any) -> any:
-        return getattr(obj, self._encode_fn)()
-
-    def decode(self, cls: Type, raw: any) -> any:
-        return getattr(cls, self._decode_fn)(raw)
 
 
-'''
+class MsgpackTypeCodec(TypeCodec):
-Default codec descriptions for wire types:
+    ...
-
-    - bytes
-    - str
-    - int
-
-'''
 
 
-BytesCodec = TypeCodec(
+def mk_codec_hooks(
-    decode_fn='from_bytes',
+    type_codecs: list[TypeCodec],
-    wire_type=bytes
-)
 
-
+) -> tuple[Callable, Callable]:
-StrCodec = TypeCodec(
-    decode_fn='from_str',
-    wire_type=str
-)
-
-
-IntCodec = TypeCodec(
-    decode_fn='from_int',
-    wire_type=int
-)
-
-
-default_codecs: dict[Type, TypeCodec] = {
-    bytes: BytesCodec,
-    str: StrCodec,
-    int: IntCodec
-}
-
-
-def mk_spec_set(
-    spec: TypeSpec
-) -> set[Type]:
     '''
-    Given any of the different spec definitions, always return a `set[Type]`
+    Deliver a `enc_hook()`/`dec_hook()` pair which handle
-    with each spec type as an item.
+    manual convertion from an input `Type` set such that whenever
-
+    the `TypeCodec.filter()` predicate matches the
-    - When passed list|tuple|set do nothing
+    `TypeCodec.decode()` is called on the input native object by
-    - When passed a single type we wrap it in tuple
+    the `dec_hook()` and whenever the
-    - When passed a Union we wrap its inner types in tuple
+    `isiinstance(obj, TypeCodec.type)` matches against an
+    `enc_hook(obj=obj)` the return value is taken from a
+    `TypeCodec.encode(obj)` callback.
 
     '''
-    if not (
+    ...
-        isinstance(spec, set)
-        or
-        isinstance(spec, list)
-        or
-        isinstance(spec, tuple)
-    ):
-        spec_info = msgspec.inspect.type_info(spec)
-        match spec_info:
-            case UnionType():
-                return set((
-                    t.cls
-                    for t in spec_info.types
-                ))
-
-            case _:
-                return set((spec, ))
-
-    return set(spec)
-
-
-def mk_codec_map_from_spec(
-    spec: TypeSpec,
-    codecs: dict[Type, TypeCodec] = default_codecs
-) -> dict[Type, TypeCodec]:
-    '''
-    Generate a map of spec type -> supported codec
-
-    '''
-    spec: set[Type] = mk_spec_set(spec)
-
-    spec_codecs: dict[Type, TypeCodec] = {}
-    for t in spec:
-        if t in spec_codecs:
-            continue
-
-        for codec_type in (int, bytes, str):
-            codec = codecs[codec_type]
-            if codec.is_type_compat(t):
-                spec_codecs[t] = codec
-                break
-
-    return spec_codecs
-
-
-def mk_enc_hook(
-    spec: TypeSpec,
-    with_builtins: bool = True,
-    builtins: set[Type] = default_builtins,
-    codecs: dict[Type, TypeCodec] = default_codecs
-) -> Callable:
-    '''
-    Given a type specification return a msgspec enc_hook fn
-
-    '''
-    spec_codecs = mk_codec_map_from_spec(spec)
-
-    def enc_hook(obj: any) -> any:
-        try:
-            t = type(obj)
-            maybe_codec = spec_codecs.get(t, None)
-            if maybe_codec:
-                return maybe_codec.encode(obj)
-
-            # passthrough builtins
-            if builtins and t in builtins:
-                return obj
-
-            raise NotImplementedError(
-                f"Objects of type {type(obj)} are not supported:\n{obj}"
-            )
-
-        except* Exception as e:
-            e.add_note(f'enc_hook: {t}, {type(obj)} {obj}')
-            raise
-
-    return enc_hook
-
-
-def mk_dec_hook(
-    spec: TypeSpec,
-    with_builtins: bool = True,
-    builtins: set[Type] = default_builtins,
-    codecs: dict[Type, TypeCodec] = default_codecs
-) -> Callable:
-    '''
-    Given a type specification return a msgspec dec_hook fn
-
-    '''
-    spec_codecs = mk_codec_map_from_spec(spec)
-
-    def dec_hook(t: Type, obj: any) -> any:
-        try:
-            if t is type(obj):
-                return obj
-
-            maybe_codec = spec_codecs.get(t, None)
-            if maybe_codec:
-                return maybe_codec.decode(t, obj)
-
-            # passthrough builtins
-            if builtins and type(obj) in builtins:
-                return obj
-
-            raise NotImplementedError(
-                f"Objects of type {type} are not supported from {obj}"
-            )
-
-        except* Exception as e:
-            e.add_note(f'dec_hook: {t}, {type(obj)} {obj}')
-            raise
-
-    return dec_hook
-
-
-def mk_codec_hooks(*args, **kwargs) -> tuple[Callable, Callable]:
-    '''
-    Given a type specification return a msgspec enc & dec hook fn pair
-
-    '''
-    return (
-        mk_enc_hook(*args, **kwargs),
-
-        mk_dec_hook(*args, **kwargs)
-    )
-
-
-def mk_codec_from_spec(
-    spec: TypeSpec,
-    with_builtins: bool = True,
-    builtins: set[Type] = default_builtins,
-    codecs: dict[Type, TypeCodec] = default_codecs
-) -> MsgCodec:
-    '''
-    Given a type specification return a MsgCodec
-
-    '''
-    spec: set[Type] = mk_spec_set(spec)
-
-    return mk_codec(
-        enc_hook=mk_enc_hook(
-            spec,
-            with_builtins=with_builtins,
-            builtins=builtins,
-            codecs=codecs
-        ),
-        ext_types=spec
-    )
-
-
-def mk_msgpack_codec(
-    spec: TypeSpec,
-    with_builtins: bool = True,
-    builtins: set[Type] = default_builtins,
-    codecs: dict[Type, TypeCodec] = default_codecs
-) -> tuple[msgpack.Encoder, msgpack.Decoder]:
-    '''
-    Get a msgpack Encoder, Decoder pair for a given type spec
-
-    '''
-    enc_hook, dec_hook = mk_codec_hooks(
-        spec,
-        with_builtins=with_builtins,
-        builtins=builtins,
-        codecs=codecs
-    )
-    encoder = msgpack.Encoder(enc_hook=enc_hook)
-    decoder = msgpack.Decoder(spec, dec_hook=dec_hook)
-    return encoder, decoder

tractor/msg/types.py

@@ -31,7 +31,6 @@ from typing import (
     Type,
     TypeVar,
     TypeAlias,
-    # TYPE_CHECKING,
     Union,
 )
 
@@ -48,7 +47,6 @@ from tractor.msg import (
     pretty_struct,
 )
 from tractor.log import get_logger
-# from tractor._addr import UnwrappedAddress
 
 
 log = get_logger('tractor.msgspec')
@@ -143,16 +141,9 @@ class Aid(
     '''
     name: str
     uuid: str
-    pid: int|None = None
+    # TODO: use built-in support for UUIDs?
-
+    # -[ ] `uuid.UUID` which has multi-protocol support
-    # TODO? can/should we extend this field set?
+    #  https://jcristharif.com/msgspec/supported-types.html#uuid
-    # -[ ] use built-in support for UUIDs? `uuid.UUID` which has
-    #     multi-protocol support
-    #     https://jcristharif.com/msgspec/supported-types.html#uuid
-    #
-    # -[ ] as per the `.ipc._uds` / `._addr` comments, maybe we
-    #     should also include at least `.pid` (equiv to port for tcp)
-    #     and/or host-part always?
 
 
 class SpawnSpec(
@@ -176,8 +167,8 @@ class SpawnSpec(
 
     # TODO: not just sockaddr pairs?
     # -[ ] abstract into a `TransportAddr` type?
-    reg_addrs: list[tuple[str, str|int]]
+    reg_addrs: list[tuple[str, int]]
-    bind_addrs: list[tuple[str, str|int]]|None
+    bind_addrs: list[tuple[str, int]]
 
 
 # TODO: caps based RPC support in the payload?

uv.lock

@@ -2,31 +2,13 @@ version = 1
 revision = 1
 requires-python = ">=3.11"
 
-[[package]]
-name = "async-generator"
-version = "1.10"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/ce/b6/6fa6b3b598a03cba5e80f829e0dadbb49d7645f523d209b2fb7ea0bbb02a/async_generator-1.10.tar.gz", hash = "sha256:6ebb3d106c12920aaae42ccb6f787ef5eefdcdd166ea3d628fa8476abe712144", size = 29870 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/71/52/39d20e03abd0ac9159c162ec24b93fbcaa111e8400308f2465432495ca2b/async_generator-1.10-py3-none-any.whl", hash = "sha256:01c7bf666359b4967d2cda0000cc2e4af16a0ae098cbffcb8472fb9e8ad6585b", size = 18857 },
-]
-
 [[package]]
 name = "attrs"
-version = "25.3.0"
+version = "24.3.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/5a/b0/1367933a8532ee6ff8d63537de4f1177af4bff9f3e829baf7331f595bb24/attrs-25.3.0.tar.gz", hash = "sha256:75d7cefc7fb576747b2c81b4442d4d4a1ce0900973527c011d1030fd3bf4af1b", size = 812032 }
+sdist = { url = "https://files.pythonhosted.org/packages/48/c8/6260f8ccc11f0917360fc0da435c5c9c7504e3db174d5a12a1494887b045/attrs-24.3.0.tar.gz", hash = "sha256:8f5c07333d543103541ba7be0e2ce16eeee8130cb0b3f9238ab904ce1e85baff", size = 805984 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/77/06/bb80f5f86020c4551da315d78b3ab75e8228f89f0162f2c3a819e407941a/attrs-25.3.0-py3-none-any.whl", hash = "sha256:427318ce031701fea540783410126f03899a97ffc6f61596ad581ac2e40e3bc3", size = 63815 },
+    { url = "https://files.pythonhosted.org/packages/89/aa/ab0f7891a01eeb2d2e338ae8fecbe57fcebea1a24dbb64d45801bfab481d/attrs-24.3.0-py3-none-any.whl", hash = "sha256:ac96cd038792094f438ad1f6ff80837353805ac950cd2aa0e0625ef19850c308", size = 63397 },
-]
-
-[[package]]
-name = "bidict"
-version = "0.23.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/9a/6e/026678aa5a830e07cd9498a05d3e7e650a4f56a42f267a53d22bcda1bdc9/bidict-0.23.1.tar.gz", hash = "sha256:03069d763bc387bbd20e7d49914e75fc4132a41937fa3405417e1a5a2d006d71", size = 29093 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/99/37/e8730c3587a65eb5645d4aba2d27aae48e8003614d6aaf15dda67f702f1f/bidict-0.23.1-py3-none-any.whl", hash = "sha256:5dae8d4d79b552a71cbabc7deb25dfe8ce710b17ff41711e13010ead2abfc3e5", size = 32764 },
 ]
 
 [[package]]
@@ -111,45 +93,44 @@ wheels = [
 
 [[package]]
 name = "greenlet"
-version = "3.2.0"
+version = "3.1.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/b0/9c/666d8c71b18d0189cf801c0e0b31c4bfc609ac823883286045b1f3ae8994/greenlet-3.2.0.tar.gz", hash = "sha256:1d2d43bd711a43db8d9b9187500e6432ddb4fafe112d082ffabca8660a9e01a7", size = 183685 }
+sdist = { url = "https://files.pythonhosted.org/packages/2f/ff/df5fede753cc10f6a5be0931204ea30c35fa2f2ea7a35b25bdaf4fe40e46/greenlet-3.1.1.tar.gz", hash = "sha256:4ce3ac6cdb6adf7946475d7ef31777c26d94bccc377e070a7986bd2d5c515467", size = 186022 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2d/d3/0a25528e54eca3c57524d2ef1f63283c8c6db466c785218036ab7fc2d4ff/greenlet-3.2.0-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:b99de16560097b9984409ded0032f101f9555e1ab029440fc6a8b5e76dbba7ac", size = 268620 },
+    { url = "https://files.pythonhosted.org/packages/28/62/1c2665558618553c42922ed47a4e6d6527e2fa3516a8256c2f431c5d0441/greenlet-3.1.1-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:e4d333e558953648ca09d64f13e6d8f0523fa705f51cae3f03b5983489958c70", size = 272479 },
-    { url = "https://files.pythonhosted.org/packages/ff/40/f937eb7c1e641ca12089265c57874fcdd173c6c8aabdec3a494641d81eb9/greenlet-3.2.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a0bc5776ac2831c022e029839bf1b9d3052332dcf5f431bb88c8503e27398e31", size = 628787 },
+    { url = "https://files.pythonhosted.org/packages/76/9d/421e2d5f07285b6e4e3a676b016ca781f63cfe4a0cd8eaecf3fd6f7a71ae/greenlet-3.1.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:09fc016b73c94e98e29af67ab7b9a879c307c6731a2c9da0db5a7d9b7edd1159", size = 640404 },
-    { url = "https://files.pythonhosted.org/packages/12/8d/f248691502cb85ce8b18d442032dbde5d3dd16ff2d15593cbee33c40f29c/greenlet-3.2.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1dcb1108449b55ff6bc0edac9616468f71db261a4571f27c47ccf3530a7f8b97", size = 640838 },
+    { url = "https://files.pythonhosted.org/packages/e5/de/6e05f5c59262a584e502dd3d261bbdd2c97ab5416cc9c0b91ea38932a901/greenlet-3.1.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d5e975ca70269d66d17dd995dafc06f1b06e8cb1ec1e9ed54c1d1e4a7c4cf26e", size = 652813 },
-    { url = "https://files.pythonhosted.org/packages/d5/f1/2a572bf4fc667e8835ed8c4ef8b729eccd0666ed9e6db8c61c5796fd2dc9/greenlet-3.2.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:82a68a25a08f51fc8b66b113d1d9863ee123cdb0e8f1439aed9fc795cd6f85cf", size = 636760 },
+    { url = "https://files.pythonhosted.org/packages/49/93/d5f93c84241acdea15a8fd329362c2c71c79e1a507c3f142a5d67ea435ae/greenlet-3.1.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3b2813dc3de8c1ee3f924e4d4227999285fd335d1bcc0d2be6dc3f1f6a318ec1", size = 648517 },
-    { url = "https://files.pythonhosted.org/packages/12/d6/f9ecc8dcb17516a0f4ab91df28497303e8d2d090d509fe3e1b1a85b23e90/greenlet-3.2.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7fee6f518868e8206c617f4084a83ad4d7a3750b541bf04e692dfa02e52e805d", size = 636001 },
+    { url = "https://files.pythonhosted.org/packages/15/85/72f77fc02d00470c86a5c982b8daafdf65d38aefbbe441cebff3bf7037fc/greenlet-3.1.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e347b3bfcf985a05e8c0b7d462ba6f15b1ee1c909e2dcad795e49e91b152c383", size = 647831 },
-    { url = "https://files.pythonhosted.org/packages/fc/b2/28ab943ff898d6aad3e0ab88fad722c892a43375fabb9789dcc29075da36/greenlet-3.2.0-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6fad8a9ca98b37951a053d7d2d2553569b151cd8c4ede744806b94d50d7f8f73", size = 583936 },
+    { url = "https://files.pythonhosted.org/packages/f7/4b/1c9695aa24f808e156c8f4813f685d975ca73c000c2a5056c514c64980f6/greenlet-3.1.1-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9e8f8c9cb53cdac7ba9793c276acd90168f416b9ce36799b9b885790f8ad6c0a", size = 602413 },
-    { url = "https://files.pythonhosted.org/packages/44/a8/dedd1517fae684c3c08ff53ab8b03e328015da4b52d2bd993279ac3a8c3d/greenlet-3.2.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:0e14541f9024a280adb9645143d6a0a51fda6f7c5695fd96cb4d542bb563442f", size = 1112901 },
+    { url = "https://files.pythonhosted.org/packages/76/70/ad6e5b31ef330f03b12559d19fda2606a522d3849cde46b24f223d6d1619/greenlet-3.1.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:62ee94988d6b4722ce0028644418d93a52429e977d742ca2ccbe1c4f4a792511", size = 1129619 },
-    { url = "https://files.pythonhosted.org/packages/45/23/15cf5d4bc864c3dc0dcb708bcaa81cd1a3dc2012326d32ad8a46d77a645e/greenlet-3.2.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:7f163d04f777e7bd229a50b937ecc1ae2a5b25296e6001445e5433e4f51f5191", size = 1138328 },
+    { url = "https://files.pythonhosted.org/packages/f4/fb/201e1b932e584066e0f0658b538e73c459b34d44b4bd4034f682423bc801/greenlet-3.1.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:1776fd7f989fc6b8d8c8cb8da1f6b82c5814957264d1f6cf818d475ec2bf6395", size = 1155198 },
-    { url = "https://files.pythonhosted.org/packages/ba/82/c7cf91e89451a922c049ac1f0123de091260697e26e8b98d299555ad96a5/greenlet-3.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:39801e633a978c3f829f21022501e7b0c3872683d7495c1850558d1a6fb95ed0", size = 295415 },
+    { url = "https://files.pythonhosted.org/packages/12/da/b9ed5e310bb8b89661b80cbcd4db5a067903bbcd7fc854923f5ebb4144f0/greenlet-3.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:48ca08c771c268a768087b408658e216133aecd835c0ded47ce955381105ba39", size = 298930 },
-    { url = "https://files.pythonhosted.org/packages/0e/8d/3c55e88ab01866fb696f68d6c94587a1b7ec8c8a9c56b1383ad05bc14811/greenlet-3.2.0-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:7d08b88ee8d506ca1f5b2a58744e934d33c6a1686dd83b81e7999dfc704a912f", size = 270391 },
+    { url = "https://files.pythonhosted.org/packages/7d/ec/bad1ac26764d26aa1353216fcbfa4670050f66d445448aafa227f8b16e80/greenlet-3.1.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:4afe7ea89de619adc868e087b4d2359282058479d7cfb94970adf4b55284574d", size = 274260 },
-    { url = "https://files.pythonhosted.org/packages/8b/6f/4a15185a386992ba4fbb55f88c1a189b75c7ce6e145b43ae4e50754d1969/greenlet-3.2.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:58ef3d637c54e2f079064ca936556c4af3989144e4154d80cfd4e2a59fc3769c", size = 637202 },
+    { url = "https://files.pythonhosted.org/packages/66/d4/c8c04958870f482459ab5956c2942c4ec35cac7fe245527f1039837c17a9/greenlet-3.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f406b22b7c9a9b4f8aa9d2ab13d6ae0ac3e85c9a809bd590ad53fed2bf70dc79", size = 649064 },
-    { url = "https://files.pythonhosted.org/packages/71/f8/60214debfe3b9670bafac97bfc40e318cbddb4ff4b5cf07df119c4a56dcd/greenlet-3.2.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:33ea7e7269d6f7275ce31f593d6dcfedd97539c01f63fbdc8d84e493e20b1b2c", size = 651391 },
+    { url = "https://files.pythonhosted.org/packages/51/41/467b12a8c7c1303d20abcca145db2be4e6cd50a951fa30af48b6ec607581/greenlet-3.1.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c3a701fe5a9695b238503ce5bbe8218e03c3bcccf7e204e455e7462d770268aa", size = 663420 },
-    { url = "https://files.pythonhosted.org/packages/a9/44/fb5e067a728a4df73a30863973912ba6eb01f3d910caaf129ef789ca222d/greenlet-3.2.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e61d426969b68b2170a9f853cc36d5318030494576e9ec0bfe2dc2e2afa15a68", size = 646118 },
+    { url = "https://files.pythonhosted.org/packages/27/8f/2a93cd9b1e7107d5c7b3b7816eeadcac2ebcaf6d6513df9abaf0334777f6/greenlet-3.1.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2846930c65b47d70b9d178e89c7e1a69c95c1f68ea5aa0a58646b7a96df12441", size = 658035 },
-    { url = "https://files.pythonhosted.org/packages/f0/3e/f329b452869d8bc07dbaa112c0175de5e666a7d15eb243781481fb59b863/greenlet-3.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:04e781447a4722e30b4861af728cb878d73a3df79509dc19ea498090cea5d204", size = 648079 },
+    { url = "https://files.pythonhosted.org/packages/57/5c/7c6f50cb12be092e1dccb2599be5a942c3416dbcfb76efcf54b3f8be4d8d/greenlet-3.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:99cfaa2110534e2cf3ba31a7abcac9d328d1d9f1b95beede58294a60348fba36", size = 660105 },
-    { url = "https://files.pythonhosted.org/packages/56/e5/813a2e8e842289579391cbd3ae6e6e6a3d2fcad8bdd89bd549a4035ab057/greenlet-3.2.0-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b2392cc41eeed4055978c6b52549ccd9effd263bb780ffd639c0e1e7e2055ab0", size = 603825 },
+    { url = "https://files.pythonhosted.org/packages/f1/66/033e58a50fd9ec9df00a8671c74f1f3a320564c6415a4ed82a1c651654ba/greenlet-3.1.1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1443279c19fca463fc33e65ef2a935a5b09bb90f978beab37729e1c3c6c25fe9", size = 613077 },
-    { url = "https://files.pythonhosted.org/packages/4a/11/0bad66138622d0c1463b0b87935cefd397f9f04fac325a838525a3aa4da7/greenlet-3.2.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:430cba962c85e339767235a93450a6aaffed6f9c567e73874ea2075f5aae51e1", size = 1119582 },
+    { url = "https://files.pythonhosted.org/packages/19/c5/36384a06f748044d06bdd8776e231fadf92fc896bd12cb1c9f5a1bda9578/greenlet-3.1.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:b7cede291382a78f7bb5f04a529cb18e068dd29e0fb27376074b6d0317bf4dd0", size = 1135975 },
-    { url = "https://files.pythonhosted.org/packages/17/26/0f8a4d222b9014af88bb8b5d921305308dd44de667c01714817dc9fb91fb/greenlet-3.2.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:5e57ff52315bfc0c5493917f328b8ba3ae0c0515d94524453c4d24e7638cbb53", size = 1147452 },
+    { url = "https://files.pythonhosted.org/packages/38/f9/c0a0eb61bdf808d23266ecf1d63309f0e1471f284300ce6dac0ae1231881/greenlet-3.1.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:23f20bb60ae298d7d8656c6ec6db134bca379ecefadb0b19ce6f19d1f232a942", size = 1163955 },
-    { url = "https://files.pythonhosted.org/packages/8a/d4/70d262492338c4939f97dca310c45b002a3af84b265720f0e9b135bc85b2/greenlet-3.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:211a9721f540e454a02e62db7956263e9a28a6cf776d4b9a7213844e36426333", size = 296217 },
+    { url = "https://files.pythonhosted.org/packages/43/21/a5d9df1d21514883333fc86584c07c2b49ba7c602e670b174bd73cfc9c7f/greenlet-3.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:7124e16b4c55d417577c2077be379514321916d5790fa287c9ed6f23bd2ffd01", size = 299655 },
-    { url = "https://files.pythonhosted.org/packages/c9/43/c0b655d4d7eae19282b028bcec449e5c80626ad0d8d0ca3703f9b1c29258/greenlet-3.2.0-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:b86a3ccc865ae601f446af042707b749eebc297928ea7bd0c5f60c56525850be", size = 269131 },
+    { url = "https://files.pythonhosted.org/packages/f3/57/0db4940cd7bb461365ca8d6fd53e68254c9dbbcc2b452e69d0d41f10a85e/greenlet-3.1.1-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:05175c27cb459dcfc05d026c4232f9de8913ed006d42713cb8a5137bd49375f1", size = 272990 },
-    { url = "https://files.pythonhosted.org/packages/7c/7d/c8f51c373c7f7ac0f73d04a6fd77ab34f6f643cb41a0d186d05ba96708e7/greenlet-3.2.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:144283ad88ed77f3ebd74710dd419b55dd15d18704b0ae05935766a93f5671c5", size = 637323 },
+    { url = "https://files.pythonhosted.org/packages/1c/ec/423d113c9f74e5e402e175b157203e9102feeb7088cee844d735b28ef963/greenlet-3.1.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:935e943ec47c4afab8965954bf49bfa639c05d4ccf9ef6e924188f762145c0ff", size = 649175 },
-    { url = "https://files.pythonhosted.org/packages/89/65/c3ee41b2e56586737d6e124b250583695628ffa6b324855b3a1267a8d1d9/greenlet-3.2.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5be69cd50994b8465c3ad1467f9e63001f76e53a89440ad4440d1b6d52591280", size = 651430 },
+    { url = "https://files.pythonhosted.org/packages/a9/46/ddbd2db9ff209186b7b7c621d1432e2f21714adc988703dbdd0e65155c77/greenlet-3.1.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:667a9706c970cb552ede35aee17339a18e8f2a87a51fba2ed39ceeeb1004798a", size = 663425 },
-    { url = "https://files.pythonhosted.org/packages/f0/07/33bd7a3dcde1db7259371d026ce76be1eb653d2d892334fc79a500b3c5ee/greenlet-3.2.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:47aeadd1e8fbdef8fdceb8fb4edc0cbb398a57568d56fd68f2bc00d0d809e6b6", size = 645798 },
+    { url = "https://files.pythonhosted.org/packages/bc/f9/9c82d6b2b04aa37e38e74f0c429aece5eeb02bab6e3b98e7db89b23d94c6/greenlet-3.1.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b8a678974d1f3aa55f6cc34dc480169d58f2e6d8958895d68845fa4ab566509e", size = 657736 },
-    { url = "https://files.pythonhosted.org/packages/35/5b/33c221a6a867030b0b770513a1b78f6c30e04294131dafdc8da78906bbe6/greenlet-3.2.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:18adc14ab154ca6e53eecc9dc50ff17aeb7ba70b7e14779b26e16d71efa90038", size = 648271 },
+    { url = "https://files.pythonhosted.org/packages/d9/42/b87bc2a81e3a62c3de2b0d550bf91a86939442b7ff85abb94eec3fc0e6aa/greenlet-3.1.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:efc0f674aa41b92da8c49e0346318c6075d734994c3c4e4430b1c3f853e498e4", size = 660347 },
-    { url = "https://files.pythonhosted.org/packages/4d/dd/d6452248fa6093504e3b7525dc2bdc4e55a4296ec6ee74ba241a51d852e2/greenlet-3.2.0-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e8622b33d8694ec373ad55050c3d4e49818132b44852158442e1931bb02af336", size = 606779 },
+    { url = "https://files.pythonhosted.org/packages/37/fa/71599c3fd06336cdc3eac52e6871cfebab4d9d70674a9a9e7a482c318e99/greenlet-3.1.1-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0153404a4bb921f0ff1abeb5ce8a5131da56b953eda6e14b88dc6bbc04d2049e", size = 615583 },
-    { url = "https://files.pythonhosted.org/packages/9d/24/160f04d2589bcb15b8661dcd1763437b22e01643626899a4139bf98f02af/greenlet-3.2.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:e8ac9a2c20fbff3d0b853e9ef705cdedb70d9276af977d1ec1cde86a87a4c821", size = 1117968 },
+    { url = "https://files.pythonhosted.org/packages/4e/96/e9ef85de031703ee7a4483489b40cf307f93c1824a02e903106f2ea315fe/greenlet-3.1.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:275f72decf9932639c1c6dd1013a1bc266438eb32710016a1c742df5da6e60a1", size = 1133039 },
-    { url = "https://files.pythonhosted.org/packages/6c/ff/c6e3f3a5168fef5209cfd9498b2b5dd77a0bf29dfc686a03dcc614cf4432/greenlet-3.2.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:cd37273dc7ca1d5da149b58c8b3ce0711181672ba1b09969663905a765affe21", size = 1145510 },
+    { url = "https://files.pythonhosted.org/packages/87/76/b2b6362accd69f2d1889db61a18c94bc743e961e3cab344c2effaa4b4a25/greenlet-3.1.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:c4aab7f6381f38a4b42f269057aee279ab0fc7bf2e929e3d4abfae97b682a12c", size = 1160716 },
-    { url = "https://files.pythonhosted.org/packages/dc/62/5215e374819052e542b5bde06bd7d4a171454b6938c96a2384f21cb94279/greenlet-3.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:8a8940a8d301828acd8b9f3f85db23069a692ff2933358861b19936e29946b95", size = 296004 },
+    { url = "https://files.pythonhosted.org/packages/1f/1b/54336d876186920e185066d8c3024ad55f21d7cc3683c856127ddb7b13ce/greenlet-3.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:b42703b1cf69f2aa1df7d1030b9d77d3e584a70755674d60e710f0af570f3761", size = 299490 },
-    { url = "https://files.pythonhosted.org/packages/62/6d/dc9c909cba5cbf4b0833fce69912927a8ca74791c23c47b9fd4f28092108/greenlet-3.2.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ee59db626760f1ca8da697a086454210d36a19f7abecc9922a2374c04b47735b", size = 629900 },
+    { url = "https://files.pythonhosted.org/packages/5f/17/bea55bf36990e1638a2af5ba10c1640273ef20f627962cf97107f1e5d637/greenlet-3.1.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f1695e76146579f8c06c1509c7ce4dfe0706f49c6831a817ac04eebb2fd02011", size = 643731 },
-    { url = "https://files.pythonhosted.org/packages/5e/a9/f3f304fbbbd604858ff3df303d7fa1d8f7f9e45a6ef74481aaf03aaac021/greenlet-3.2.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7154b13ef87a8b62fc05419f12d75532d7783586ad016c57b5de8a1c6feeb517", size = 635270 },
+    { url = "https://files.pythonhosted.org/packages/78/d2/aa3d2157f9ab742a08e0fd8f77d4699f37c22adfbfeb0c610a186b5f75e0/greenlet-3.1.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7876452af029456b3f3549b696bb36a06db7c90747740c5302f74a9e9fa14b13", size = 649304 },
-    { url = "https://files.pythonhosted.org/packages/34/92/4b7b4e2e23ecc723cceef9fe3898e78c8e14e106cc7ba2f276a66161da3e/greenlet-3.2.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:199453d64b02d0c9d139e36d29681efd0e407ed8e2c0bf89d88878d6a787c28f", size = 632534 },
+    { url = "https://files.pythonhosted.org/packages/f1/8e/d0aeffe69e53ccff5a28fa86f07ad1d2d2d6537a9506229431a2a02e2f15/greenlet-3.1.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4ead44c85f8ab905852d3de8d86f6f8baf77109f9da589cb4fa142bd3b57b475", size = 646537 },
-    { url = "https://files.pythonhosted.org/packages/da/7f/91f0ecbe72c9d789fb7f400b39da9d1e87fcc2cf8746a9636479ba79ab01/greenlet-3.2.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0010e928e1901d36625f21d008618273f9dda26b516dbdecf873937d39c9dff0", size = 628826 },
+    { url = "https://files.pythonhosted.org/packages/05/79/e15408220bbb989469c8871062c97c6c9136770657ba779711b90870d867/greenlet-3.1.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8320f64b777d00dd7ccdade271eaf0cad6636343293a25074cc5566160e4de7b", size = 642506 },
-    { url = "https://files.pythonhosted.org/packages/9f/59/e449a44ce52b13751f55376d85adc155dd311608f6d2aa5b6bd2c8d15486/greenlet-3.2.0-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6005f7a86de836a1dc4b8d824a2339cdd5a1ca7cb1af55ea92575401f9952f4c", size = 593697 },
+    { url = "https://files.pythonhosted.org/packages/18/87/470e01a940307796f1d25f8167b551a968540fbe0551c0ebb853cb527dd6/greenlet-3.1.1-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6510bf84a6b643dabba74d3049ead221257603a253d0a9873f55f6a59a65f822", size = 602753 },
-    { url = "https://files.pythonhosted.org/packages/bb/09/cca3392927c5c990b7a8ede64ccd0712808438d6490d63ce6b8704d6df5f/greenlet-3.2.0-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:17fd241c0d50bacb7ce8ff77a30f94a2d0ca69434ba2e0187cf95a5414aeb7e1", size = 1105762 },
+    { url = "https://files.pythonhosted.org/packages/e2/72/576815ba674eddc3c25028238f74d7b8068902b3968cbe456771b166455e/greenlet-3.1.1-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:04b013dc07c96f83134b1e99888e7a79979f1a247e2a9f59697fa14b5862ed01", size = 1122731 },
-    { url = "https://files.pythonhosted.org/packages/4d/b9/3d201f819afc3b7a8cd7ebe645f1a17799603e2d62c968154518f79f4881/greenlet-3.2.0-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:7b17a26abc6a1890bf77d5d6b71c0999705386b00060d15c10b8182679ff2790", size = 1125173 },
+    { url = "https://files.pythonhosted.org/packages/ac/38/08cc303ddddc4b3d7c628c3039a61a3aae36c241ed01393d00c2fd663473/greenlet-3.1.1-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:411f015496fec93c1c8cd4e5238da364e1da7a124bcb293f085bf2860c32c6f6", size = 1142112 },
-    { url = "https://files.pythonhosted.org/packages/80/7b/773a30602234597fc2882091f8e1d1a38ea0b4419d99ca7ed82c827e2c3a/greenlet-3.2.0-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:397b6bbda06f8fe895893d96218cd6f6d855a6701dc45012ebe12262423cec8b", size = 269908 },
 ]
 
 [[package]]
@@ -161,25 +142,13 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442 },
 ]
 
-[[package]]
-name = "importlib-metadata"
-version = "8.6.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "zipp" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/33/08/c1395a292bb23fd03bdf572a1357c5a733d3eecbab877641ceacab23db6e/importlib_metadata-8.6.1.tar.gz", hash = "sha256:310b41d755445d74569f993ccfc22838295d9fe005425094fad953d7f15c8580", size = 55767 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/79/9d/0fb148dc4d6fa4a7dd1d8378168d9b4cd8d4560a6fbf6f0121c5fc34eb68/importlib_metadata-8.6.1-py3-none-any.whl", hash = "sha256:02a89390c1e15fdfdc0d7c6b25cb3e62650d0494005c97d6f148bf5b9787525e", size = 26971 },
-]
-
 [[package]]
 name = "iniconfig"
-version = "2.1.0"
+version = "2.0.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f2/97/ebf4da567aa6827c909642694d71c9fcf53e5b504f2d96afea02718862f3/iniconfig-2.1.0.tar.gz", hash = "sha256:3abbd2e30b36733fee78f9c7f7308f2d0050e88f0087fd25c2645f63c773e1c7", size = 4793 }
+sdist = { url = "https://files.pythonhosted.org/packages/d7/4b/cbd8e699e64a6f16ca3a8220661b5f83792b3017d0f79807cb8708d33913/iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3", size = 4646 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/e1/e6716421ea10d38022b952c159d5161ca1193197fb744506875fbb87ea7b/iniconfig-2.1.0-py3-none-any.whl", hash = "sha256:9deba5723312380e77435581c6bf4935c94cbfab9b1ed33ef8d238ea168eb760", size = 6050 },
+    { url = "https://files.pythonhosted.org/packages/ef/a6/62565a6e1cf69e10f5727360368e451d4b7f58beeac6173dc9db836a5b46/iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374", size = 5892 },
 ]
 
 [[package]]
@@ -211,92 +180,52 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/23/d8/f15b40611c2d5753d1abb0ca0da0c75348daf1252220e5dda2867bd81062/msgspec-0.19.0-cp313-cp313-win_amd64.whl", hash = "sha256:317050bc0f7739cb30d257ff09152ca309bf5a369854bbf1e57dffc310c1f20f", size = 187432 },
 ]
 
-[[package]]
-name = "mypy"
-version = "1.15.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "mypy-extensions" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/ce/43/d5e49a86afa64bd3839ea0d5b9c7103487007d728e1293f52525d6d5486a/mypy-1.15.0.tar.gz", hash = "sha256:404534629d51d3efea5c800ee7c42b72a6554d6c400e6a79eafe15d11341fd43", size = 3239717 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/03/bc/f6339726c627bd7ca1ce0fa56c9ae2d0144604a319e0e339bdadafbbb599/mypy-1.15.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2922d42e16d6de288022e5ca321cd0618b238cfc5570e0263e5ba0a77dbef56f", size = 10662338 },
-    { url = "https://files.pythonhosted.org/packages/e2/90/8dcf506ca1a09b0d17555cc00cd69aee402c203911410136cd716559efe7/mypy-1.15.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2ee2d57e01a7c35de00f4634ba1bbf015185b219e4dc5909e281016df43f5ee5", size = 9787540 },
-    { url = "https://files.pythonhosted.org/packages/05/05/a10f9479681e5da09ef2f9426f650d7b550d4bafbef683b69aad1ba87457/mypy-1.15.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:973500e0774b85d9689715feeffcc980193086551110fd678ebe1f4342fb7c5e", size = 11538051 },
-    { url = "https://files.pythonhosted.org/packages/e9/9a/1f7d18b30edd57441a6411fcbc0c6869448d1a4bacbaee60656ac0fc29c8/mypy-1.15.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a95fb17c13e29d2d5195869262f8125dfdb5c134dc8d9a9d0aecf7525b10c2c", size = 12286751 },
-    { url = "https://files.pythonhosted.org/packages/72/af/19ff499b6f1dafcaf56f9881f7a965ac2f474f69f6f618b5175b044299f5/mypy-1.15.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1905f494bfd7d85a23a88c5d97840888a7bd516545fc5aaedff0267e0bb54e2f", size = 12421783 },
-    { url = "https://files.pythonhosted.org/packages/96/39/11b57431a1f686c1aed54bf794870efe0f6aeca11aca281a0bd87a5ad42c/mypy-1.15.0-cp311-cp311-win_amd64.whl", hash = "sha256:c9817fa23833ff189db061e6d2eff49b2f3b6ed9856b4a0a73046e41932d744f", size = 9265618 },
-    { url = "https://files.pythonhosted.org/packages/98/3a/03c74331c5eb8bd025734e04c9840532226775c47a2c39b56a0c8d4f128d/mypy-1.15.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:aea39e0583d05124836ea645f412e88a5c7d0fd77a6d694b60d9b6b2d9f184fd", size = 10793981 },
-    { url = "https://files.pythonhosted.org/packages/f0/1a/41759b18f2cfd568848a37c89030aeb03534411eef981df621d8fad08a1d/mypy-1.15.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2f2147ab812b75e5b5499b01ade1f4a81489a147c01585cda36019102538615f", size = 9749175 },
-    { url = "https://files.pythonhosted.org/packages/12/7e/873481abf1ef112c582db832740f4c11b2bfa510e829d6da29b0ab8c3f9c/mypy-1.15.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ce436f4c6d218a070048ed6a44c0bbb10cd2cc5e272b29e7845f6a2f57ee4464", size = 11455675 },
-    { url = "https://files.pythonhosted.org/packages/b3/d0/92ae4cde706923a2d3f2d6c39629134063ff64b9dedca9c1388363da072d/mypy-1.15.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8023ff13985661b50a5928fc7a5ca15f3d1affb41e5f0a9952cb68ef090b31ee", size = 12410020 },
-    { url = "https://files.pythonhosted.org/packages/46/8b/df49974b337cce35f828ba6fda228152d6db45fed4c86ba56ffe442434fd/mypy-1.15.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1124a18bc11a6a62887e3e137f37f53fbae476dc36c185d549d4f837a2a6a14e", size = 12498582 },
-    { url = "https://files.pythonhosted.org/packages/13/50/da5203fcf6c53044a0b699939f31075c45ae8a4cadf538a9069b165c1050/mypy-1.15.0-cp312-cp312-win_amd64.whl", hash = "sha256:171a9ca9a40cd1843abeca0e405bc1940cd9b305eaeea2dda769ba096932bb22", size = 9366614 },
-    { url = "https://files.pythonhosted.org/packages/6a/9b/fd2e05d6ffff24d912f150b87db9e364fa8282045c875654ce7e32fffa66/mypy-1.15.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:93faf3fdb04768d44bf28693293f3904bbb555d076b781ad2530214ee53e3445", size = 10788592 },
-    { url = "https://files.pythonhosted.org/packages/74/37/b246d711c28a03ead1fd906bbc7106659aed7c089d55fe40dd58db812628/mypy-1.15.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:811aeccadfb730024c5d3e326b2fbe9249bb7413553f15499a4050f7c30e801d", size = 9753611 },
-    { url = "https://files.pythonhosted.org/packages/a6/ac/395808a92e10cfdac8003c3de9a2ab6dc7cde6c0d2a4df3df1b815ffd067/mypy-1.15.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:98b7b9b9aedb65fe628c62a6dc57f6d5088ef2dfca37903a7d9ee374d03acca5", size = 11438443 },
-    { url = "https://files.pythonhosted.org/packages/d2/8b/801aa06445d2de3895f59e476f38f3f8d610ef5d6908245f07d002676cbf/mypy-1.15.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c43a7682e24b4f576d93072216bf56eeff70d9140241f9edec0c104d0c515036", size = 12402541 },
-    { url = "https://files.pythonhosted.org/packages/c7/67/5a4268782eb77344cc613a4cf23540928e41f018a9a1ec4c6882baf20ab8/mypy-1.15.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:baefc32840a9f00babd83251560e0ae1573e2f9d1b067719479bfb0e987c6357", size = 12494348 },
-    { url = "https://files.pythonhosted.org/packages/83/3e/57bb447f7bbbfaabf1712d96f9df142624a386d98fb026a761532526057e/mypy-1.15.0-cp313-cp313-win_amd64.whl", hash = "sha256:b9378e2c00146c44793c98b8d5a61039a048e31f429fb0eb546d93f4b000bedf", size = 9373648 },
-    { url = "https://files.pythonhosted.org/packages/09/4e/a7d65c7322c510de2c409ff3828b03354a7c43f5a8ed458a7a131b41c7b9/mypy-1.15.0-py3-none-any.whl", hash = "sha256:5469affef548bd1895d86d3bf10ce2b44e33d86923c29e4d675b3e323437ea3e", size = 2221777 },
-]
-
-[[package]]
-name = "mypy-extensions"
-version = "1.0.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/98/a4/1ab47638b92648243faf97a5aeb6ea83059cc3624972ab6b8d2316078d3f/mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782", size = 4433 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2a/e2/5d3f6ada4297caebe1a2add3b126fe800c96f56dbe5d1988a2cbe0b267aa/mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d", size = 4695 },
-]
-
 [[package]]
 name = "numpy"
-version = "2.2.5"
+version = "2.2.4"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/dc/b2/ce4b867d8cd9c0ee84938ae1e6a6f7926ebf928c9090d036fc3c6a04f946/numpy-2.2.5.tar.gz", hash = "sha256:a9c0d994680cd991b1cb772e8b297340085466a6fe964bc9d4e80f5e2f43c291", size = 20273920 }
+sdist = { url = "https://files.pythonhosted.org/packages/e1/78/31103410a57bc2c2b93a3597340a8119588571f6a4539067546cb9a0bfac/numpy-2.2.4.tar.gz", hash = "sha256:9ba03692a45d3eef66559efe1d1096c4b9b75c0986b5dff5530c378fb8331d4f", size = 20270701 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f5/fb/e4e4c254ba40e8f0c78218f9e86304628c75b6900509b601c8433bdb5da7/numpy-2.2.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c42365005c7a6c42436a54d28c43fe0e01ca11eb2ac3cefe796c25a5f98e5e9b", size = 21256475 },
+    { url = "https://files.pythonhosted.org/packages/16/fb/09e778ee3a8ea0d4dc8329cca0a9c9e65fed847d08e37eba74cb7ed4b252/numpy-2.2.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:e9e0a277bb2eb5d8a7407e14688b85fd8ad628ee4e0c7930415687b6564207a4", size = 21254989 },
-    { url = "https://files.pythonhosted.org/packages/81/32/dd1f7084f5c10b2caad778258fdaeedd7fbd8afcd2510672811e6138dfac/numpy-2.2.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:498815b96f67dc347e03b719ef49c772589fb74b8ee9ea2c37feae915ad6ebda", size = 14461474 },
+    { url = "https://files.pythonhosted.org/packages/a2/0a/1212befdbecab5d80eca3cde47d304cad986ad4eec7d85a42e0b6d2cc2ef/numpy-2.2.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9eeea959168ea555e556b8188da5fa7831e21d91ce031e95ce23747b7609f8a4", size = 14425910 },
-    { url = "https://files.pythonhosted.org/packages/0e/65/937cdf238ef6ac54ff749c0f66d9ee2b03646034c205cea9b6c51f2f3ad1/numpy-2.2.5-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:6411f744f7f20081b1b4e7112e0f4c9c5b08f94b9f086e6f0adf3645f85d3a4d", size = 5426875 },
+    { url = "https://files.pythonhosted.org/packages/2b/3e/e7247c1d4f15086bb106c8d43c925b0b2ea20270224f5186fa48d4fb5cbd/numpy-2.2.4-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:bd3ad3b0a40e713fc68f99ecfd07124195333f1e689387c180813f0e94309d6f", size = 5426490 },
-    { url = "https://files.pythonhosted.org/packages/25/17/814515fdd545b07306eaee552b65c765035ea302d17de1b9cb50852d2452/numpy-2.2.5-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:9de6832228f617c9ef45d948ec1cd8949c482238d68b2477e6f642c33a7b0a54", size = 6969176 },
+    { url = "https://files.pythonhosted.org/packages/5d/fa/aa7cd6be51419b894c5787a8a93c3302a1ed4f82d35beb0613ec15bdd0e2/numpy-2.2.4-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:cf28633d64294969c019c6df4ff37f5698e8326db68cc2b66576a51fad634880", size = 6967754 },
-    { url = "https://files.pythonhosted.org/packages/e5/32/a66db7a5c8b5301ec329ab36d0ecca23f5e18907f43dbd593c8ec326d57c/numpy-2.2.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:369e0d4647c17c9363244f3468f2227d557a74b6781cb62ce57cf3ef5cc7c610", size = 14374850 },
+    { url = "https://files.pythonhosted.org/packages/d5/ee/96457c943265de9fadeb3d2ffdbab003f7fba13d971084a9876affcda095/numpy-2.2.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2fa8fa7697ad1646b5c93de1719965844e004fcad23c91228aca1cf0800044a1", size = 14373079 },
-    { url = "https://files.pythonhosted.org/packages/ad/c9/1bf6ada582eebcbe8978f5feb26584cd2b39f94ededeea034ca8f84af8c8/numpy-2.2.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:262d23f383170f99cd9191a7c85b9a50970fe9069b2f8ab5d786eca8a675d60b", size = 16430306 },
+    { url = "https://files.pythonhosted.org/packages/c5/5c/ceefca458559f0ccc7a982319f37ed07b0d7b526964ae6cc61f8ad1b6119/numpy-2.2.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f4162988a360a29af158aeb4a2f4f09ffed6a969c9776f8f3bdee9b06a8ab7e5", size = 16428819 },
-    { url = "https://files.pythonhosted.org/packages/6a/f0/3f741863f29e128f4fcfdb99253cc971406b402b4584663710ee07f5f7eb/numpy-2.2.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:aa70fdbdc3b169d69e8c59e65c07a1c9351ceb438e627f0fdcd471015cd956be", size = 15884767 },
+    { url = "https://files.pythonhosted.org/packages/22/31/9b2ac8eee99e001eb6add9fa27514ef5e9faf176169057a12860af52704c/numpy-2.2.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:892c10d6a73e0f14935c31229e03325a7b3093fafd6ce0af704be7f894d95687", size = 15881470 },
-    { url = "https://files.pythonhosted.org/packages/98/d9/4ccd8fd6410f7bf2d312cbc98892e0e43c2fcdd1deae293aeb0a93b18071/numpy-2.2.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37e32e985f03c06206582a7323ef926b4e78bdaa6915095ef08070471865b906", size = 18219515 },
+    { url = "https://files.pythonhosted.org/packages/f0/dc/8569b5f25ff30484b555ad8a3f537e0225d091abec386c9420cf5f7a2976/numpy-2.2.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:db1f1c22173ac1c58db249ae48aa7ead29f534b9a948bc56828337aa84a32ed6", size = 18218144 },
-    { url = "https://files.pythonhosted.org/packages/b1/56/783237243d4395c6dd741cf16eeb1a9035ee3d4310900e6b17e875d1b201/numpy-2.2.5-cp311-cp311-win32.whl", hash = "sha256:f5045039100ed58fa817a6227a356240ea1b9a1bc141018864c306c1a16d4175", size = 6607842 },
+    { url = "https://files.pythonhosted.org/packages/5e/05/463c023a39bdeb9bb43a99e7dee2c664cb68d5bb87d14f92482b9f6011cc/numpy-2.2.4-cp311-cp311-win32.whl", hash = "sha256:ea2bb7e2ae9e37d96835b3576a4fa4b3a97592fbea8ef7c3587078b0068b8f09", size = 6606368 },
-    { url = "https://files.pythonhosted.org/packages/98/89/0c93baaf0094bdaaaa0536fe61a27b1dce8a505fa262a865ec142208cfe9/numpy-2.2.5-cp311-cp311-win_amd64.whl", hash = "sha256:b13f04968b46ad705f7c8a80122a42ae8f620536ea38cf4bdd374302926424dd", size = 12949071 },
+    { url = "https://files.pythonhosted.org/packages/8b/72/10c1d2d82101c468a28adc35de6c77b308f288cfd0b88e1070f15b98e00c/numpy-2.2.4-cp311-cp311-win_amd64.whl", hash = "sha256:f7de08cbe5551911886d1ab60de58448c6df0f67d9feb7d1fb21e9875ef95e91", size = 12947526 },
-    { url = "https://files.pythonhosted.org/packages/e2/f7/1fd4ff108cd9d7ef929b8882692e23665dc9c23feecafbb9c6b80f4ec583/numpy-2.2.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ee461a4eaab4f165b68780a6a1af95fb23a29932be7569b9fab666c407969051", size = 20948633 },
+    { url = "https://files.pythonhosted.org/packages/a2/30/182db21d4f2a95904cec1a6f779479ea1ac07c0647f064dea454ec650c42/numpy-2.2.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a7b9084668aa0f64e64bd00d27ba5146ef1c3a8835f3bd912e7a9e01326804c4", size = 20947156 },
-    { url = "https://files.pythonhosted.org/packages/12/03/d443c278348371b20d830af155ff2079acad6a9e60279fac2b41dbbb73d8/numpy-2.2.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ec31367fd6a255dc8de4772bd1658c3e926d8e860a0b6e922b615e532d320ddc", size = 14176123 },
+    { url = "https://files.pythonhosted.org/packages/24/6d/9483566acfbda6c62c6bc74b6e981c777229d2af93c8eb2469b26ac1b7bc/numpy-2.2.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:dbe512c511956b893d2dacd007d955a3f03d555ae05cfa3ff1c1ff6df8851854", size = 14133092 },
-    { url = "https://files.pythonhosted.org/packages/2b/0b/5ca264641d0e7b14393313304da48b225d15d471250376f3fbdb1a2be603/numpy-2.2.5-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:47834cde750d3c9f4e52c6ca28a7361859fcaf52695c7dc3cc1a720b8922683e", size = 5163817 },
+    { url = "https://files.pythonhosted.org/packages/27/f6/dba8a258acbf9d2bed2525cdcbb9493ef9bae5199d7a9cb92ee7e9b2aea6/numpy-2.2.4-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:bb649f8b207ab07caebba230d851b579a3c8711a851d29efe15008e31bb4de24", size = 5163515 },
-    { url = "https://files.pythonhosted.org/packages/04/b3/d522672b9e3d28e26e1613de7675b441bbd1eaca75db95680635dd158c67/numpy-2.2.5-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:2c1a1c6ccce4022383583a6ded7bbcda22fc635eb4eb1e0a053336425ed36dfa", size = 6698066 },
+    { url = "https://files.pythonhosted.org/packages/62/30/82116199d1c249446723c68f2c9da40d7f062551036f50b8c4caa42ae252/numpy-2.2.4-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:f34dc300df798742b3d06515aa2a0aee20941c13579d7a2f2e10af01ae4901ee", size = 6696558 },
-    { url = "https://files.pythonhosted.org/packages/a0/93/0f7a75c1ff02d4b76df35079676b3b2719fcdfb39abdf44c8b33f43ef37d/numpy-2.2.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9d75f338f5f79ee23548b03d801d28a505198297534f62416391857ea0479571", size = 14087277 },
+    { url = "https://files.pythonhosted.org/packages/0e/b2/54122b3c6df5df3e87582b2e9430f1bdb63af4023c739ba300164c9ae503/numpy-2.2.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c3f7ac96b16955634e223b579a3e5798df59007ca43e8d451a0e6a50f6bfdfba", size = 14084742 },
-    { url = "https://files.pythonhosted.org/packages/b0/d9/7c338b923c53d431bc837b5b787052fef9ae68a56fe91e325aac0d48226e/numpy-2.2.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3a801fef99668f309b88640e28d261991bfad9617c27beda4a3aec4f217ea073", size = 16135742 },
+    { url = "https://files.pythonhosted.org/packages/02/e2/e2cbb8d634151aab9528ef7b8bab52ee4ab10e076509285602c2a3a686e0/numpy-2.2.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4f92084defa704deadd4e0a5ab1dc52d8ac9e8a8ef617f3fbb853e79b0ea3592", size = 16134051 },
-    { url = "https://files.pythonhosted.org/packages/2d/10/4dec9184a5d74ba9867c6f7d1e9f2e0fb5fe96ff2bf50bb6f342d64f2003/numpy-2.2.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:abe38cd8381245a7f49967a6010e77dbf3680bd3627c0fe4362dd693b404c7f8", size = 15581825 },
+    { url = "https://files.pythonhosted.org/packages/8e/21/efd47800e4affc993e8be50c1b768de038363dd88865920439ef7b422c60/numpy-2.2.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7a4e84a6283b36632e2a5b56e121961f6542ab886bc9e12f8f9818b3c266bfbb", size = 15578972 },
-    { url = "https://files.pythonhosted.org/packages/80/1f/2b6fcd636e848053f5b57712a7d1880b1565eec35a637fdfd0a30d5e738d/numpy-2.2.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5a0ac90e46fdb5649ab6369d1ab6104bfe5854ab19b645bf5cda0127a13034ae", size = 17899600 },
+    { url = "https://files.pythonhosted.org/packages/04/1e/f8bb88f6157045dd5d9b27ccf433d016981032690969aa5c19e332b138c0/numpy-2.2.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:11c43995255eb4127115956495f43e9343736edb7fcdb0d973defd9de14cd84f", size = 17898106 },
-    { url = "https://files.pythonhosted.org/packages/ec/87/36801f4dc2623d76a0a3835975524a84bd2b18fe0f8835d45c8eae2f9ff2/numpy-2.2.5-cp312-cp312-win32.whl", hash = "sha256:0cd48122a6b7eab8f06404805b1bd5856200e3ed6f8a1b9a194f9d9054631beb", size = 6312626 },
+    { url = "https://files.pythonhosted.org/packages/2b/93/df59a5a3897c1f036ae8ff845e45f4081bb06943039ae28a3c1c7c780f22/numpy-2.2.4-cp312-cp312-win32.whl", hash = "sha256:65ef3468b53269eb5fdb3a5c09508c032b793da03251d5f8722b1194f1790c00", size = 6311190 },
-    { url = "https://files.pythonhosted.org/packages/8b/09/4ffb4d6cfe7ca6707336187951992bd8a8b9142cf345d87ab858d2d7636a/numpy-2.2.5-cp312-cp312-win_amd64.whl", hash = "sha256:ced69262a8278547e63409b2653b372bf4baff0870c57efa76c5703fd6543282", size = 12645715 },
+    { url = "https://files.pythonhosted.org/packages/46/69/8c4f928741c2a8efa255fdc7e9097527c6dc4e4df147e3cadc5d9357ce85/numpy-2.2.4-cp312-cp312-win_amd64.whl", hash = "sha256:2aad3c17ed2ff455b8eaafe06bcdae0062a1db77cb99f4b9cbb5f4ecb13c5146", size = 12644305 },
-    { url = "https://files.pythonhosted.org/packages/e2/a0/0aa7f0f4509a2e07bd7a509042967c2fab635690d4f48c6c7b3afd4f448c/numpy-2.2.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:059b51b658f4414fff78c6d7b1b4e18283ab5fa56d270ff212d5ba0c561846f4", size = 20935102 },
+    { url = "https://files.pythonhosted.org/packages/2a/d0/bd5ad792e78017f5decfb2ecc947422a3669a34f775679a76317af671ffc/numpy-2.2.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1cf4e5c6a278d620dee9ddeb487dc6a860f9b199eadeecc567f777daace1e9e7", size = 20933623 },
-    { url = "https://files.pythonhosted.org/packages/7e/e4/a6a9f4537542912ec513185396fce52cdd45bdcf3e9d921ab02a93ca5aa9/numpy-2.2.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:47f9ed103af0bc63182609044b0490747e03bd20a67e391192dde119bf43d52f", size = 14191709 },
+    { url = "https://files.pythonhosted.org/packages/c3/bc/2b3545766337b95409868f8e62053135bdc7fa2ce630aba983a2aa60b559/numpy-2.2.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1974afec0b479e50438fc3648974268f972e2d908ddb6d7fb634598cdb8260a0", size = 14148681 },
-    { url = "https://files.pythonhosted.org/packages/be/65/72f3186b6050bbfe9c43cb81f9df59ae63603491d36179cf7a7c8d216758/numpy-2.2.5-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:261a1ef047751bb02f29dfe337230b5882b54521ca121fc7f62668133cb119c9", size = 5149173 },
+    { url = "https://files.pythonhosted.org/packages/6a/70/67b24d68a56551d43a6ec9fe8c5f91b526d4c1a46a6387b956bf2d64744e/numpy-2.2.4-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:79bd5f0a02aa16808fcbc79a9a376a147cc1045f7dfe44c6e7d53fa8b8a79392", size = 5148759 },
-    { url = "https://files.pythonhosted.org/packages/e5/e9/83e7a9432378dde5802651307ae5e9ea07bb72b416728202218cd4da2801/numpy-2.2.5-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:4520caa3807c1ceb005d125a75e715567806fed67e315cea619d5ec6e75a4191", size = 6684502 },
+    { url = "https://files.pythonhosted.org/packages/1c/8b/e2fc8a75fcb7be12d90b31477c9356c0cbb44abce7ffb36be39a0017afad/numpy-2.2.4-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:3387dd7232804b341165cedcb90694565a6015433ee076c6754775e85d86f1fc", size = 6683092 },
-    { url = "https://files.pythonhosted.org/packages/ea/27/b80da6c762394c8ee516b74c1f686fcd16c8f23b14de57ba0cad7349d1d2/numpy-2.2.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3d14b17b9be5f9c9301f43d2e2a4886a33b53f4e6fdf9ca2f4cc60aeeee76372", size = 14084417 },
+    { url = "https://files.pythonhosted.org/packages/13/73/41b7b27f169ecf368b52533edb72e56a133f9e86256e809e169362553b49/numpy-2.2.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6f527d8fdb0286fd2fd97a2a96c6be17ba4232da346931d967a0630050dfd298", size = 14081422 },
-    { url = "https://files.pythonhosted.org/packages/aa/fc/ebfd32c3e124e6a1043e19c0ab0769818aa69050ce5589b63d05ff185526/numpy-2.2.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ba321813a00e508d5421104464510cc962a6f791aa2fca1c97b1e65027da80d", size = 16133807 },
+    { url = "https://files.pythonhosted.org/packages/4b/04/e208ff3ae3ddfbafc05910f89546382f15a3f10186b1f56bd99f159689c2/numpy-2.2.4-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bce43e386c16898b91e162e5baaad90c4b06f9dcbe36282490032cec98dc8ae7", size = 16132202 },
-    { url = "https://files.pythonhosted.org/packages/bf/9b/4cc171a0acbe4666f7775cfd21d4eb6bb1d36d3a0431f48a73e9212d2278/numpy-2.2.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4cbdef3ddf777423060c6f81b5694bad2dc9675f110c4b2a60dc0181543fac7", size = 15575611 },
+    { url = "https://files.pythonhosted.org/packages/fe/bc/2218160574d862d5e55f803d88ddcad88beff94791f9c5f86d67bd8fbf1c/numpy-2.2.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:31504f970f563d99f71a3512d0c01a645b692b12a63630d6aafa0939e52361e6", size = 15573131 },
-    { url = "https://files.pythonhosted.org/packages/a3/45/40f4135341850df48f8edcf949cf47b523c404b712774f8855a64c96ef29/numpy-2.2.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:54088a5a147ab71a8e7fdfd8c3601972751ded0739c6b696ad9cb0343e21ab73", size = 17895747 },
+    { url = "https://files.pythonhosted.org/packages/a5/78/97c775bc4f05abc8a8426436b7cb1be806a02a2994b195945600855e3a25/numpy-2.2.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:81413336ef121a6ba746892fad881a83351ee3e1e4011f52e97fba79233611fd", size = 17894270 },
-    { url = "https://files.pythonhosted.org/packages/f8/4c/b32a17a46f0ffbde8cc82df6d3daeaf4f552e346df143e1b188a701a8f09/numpy-2.2.5-cp313-cp313-win32.whl", hash = "sha256:c8b82a55ef86a2d8e81b63da85e55f5537d2157165be1cb2ce7cfa57b6aef38b", size = 6309594 },
+    { url = "https://files.pythonhosted.org/packages/b9/eb/38c06217a5f6de27dcb41524ca95a44e395e6a1decdc0c99fec0832ce6ae/numpy-2.2.4-cp313-cp313-win32.whl", hash = "sha256:f486038e44caa08dbd97275a9a35a283a8f1d2f0ee60ac260a1790e76660833c", size = 6308141 },
-    { url = "https://files.pythonhosted.org/packages/13/ae/72e6276feb9ef06787365b05915bfdb057d01fceb4a43cb80978e518d79b/numpy-2.2.5-cp313-cp313-win_amd64.whl", hash = "sha256:d8882a829fd779f0f43998e931c466802a77ca1ee0fe25a3abe50278616b1471", size = 12638356 },
+    { url = "https://files.pythonhosted.org/packages/52/17/d0dd10ab6d125c6d11ffb6dfa3423c3571befab8358d4f85cd4471964fcd/numpy-2.2.4-cp313-cp313-win_amd64.whl", hash = "sha256:207a2b8441cc8b6a2a78c9ddc64d00d20c303d79fba08c577752f080c4007ee3", size = 12636885 },
-    { url = "https://files.pythonhosted.org/packages/79/56/be8b85a9f2adb688e7ded6324e20149a03541d2b3297c3ffc1a73f46dedb/numpy-2.2.5-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:e8b025c351b9f0e8b5436cf28a07fa4ac0204d67b38f01433ac7f9b870fa38c6", size = 20963778 },
+    { url = "https://files.pythonhosted.org/packages/fa/e2/793288ede17a0fdc921172916efb40f3cbc2aa97e76c5c84aba6dc7e8747/numpy-2.2.4-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:8120575cb4882318c791f839a4fd66161a6fa46f3f0a5e613071aae35b5dd8f8", size = 20961829 },
-    { url = "https://files.pythonhosted.org/packages/ff/77/19c5e62d55bff507a18c3cdff82e94fe174957bad25860a991cac719d3ab/numpy-2.2.5-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:8dfa94b6a4374e7851bbb6f35e6ded2120b752b063e6acdd3157e4d2bb922eba", size = 14207279 },
+    { url = "https://files.pythonhosted.org/packages/3a/75/bb4573f6c462afd1ea5cbedcc362fe3e9bdbcc57aefd37c681be1155fbaa/numpy-2.2.4-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:a761ba0fa886a7bb33c6c8f6f20213735cb19642c580a931c625ee377ee8bd39", size = 14161419 },
-    { url = "https://files.pythonhosted.org/packages/75/22/aa11f22dc11ff4ffe4e849d9b63bbe8d4ac6d5fae85ddaa67dfe43be3e76/numpy-2.2.5-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:97c8425d4e26437e65e1d189d22dff4a079b747ff9c2788057bfb8114ce1e133", size = 5199247 },
+    { url = "https://files.pythonhosted.org/packages/03/68/07b4cd01090ca46c7a336958b413cdbe75002286295f2addea767b7f16c9/numpy-2.2.4-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:ac0280f1ba4a4bfff363a99a6aceed4f8e123f8a9b234c89140f5e894e452ecd", size = 5196414 },
-    { url = "https://files.pythonhosted.org/packages/4f/6c/12d5e760fc62c08eded0394f62039f5a9857f758312bf01632a81d841459/numpy-2.2.5-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:352d330048c055ea6db701130abc48a21bec690a8d38f8284e00fab256dc1376", size = 6711087 },
+    { url = "https://files.pythonhosted.org/packages/a5/fd/d4a29478d622fedff5c4b4b4cedfc37a00691079623c0575978d2446db9e/numpy-2.2.4-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:879cf3a9a2b53a4672a168c21375166171bc3932b7e21f622201811c43cdd3b0", size = 6709379 },
-    { url = "https://files.pythonhosted.org/packages/ef/94/ece8280cf4218b2bee5cec9567629e61e51b4be501e5c6840ceb593db945/numpy-2.2.5-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8b4c0773b6ada798f51f0f8e30c054d32304ccc6e9c5d93d46cb26f3d385ab19", size = 14059964 },
+    { url = "https://files.pythonhosted.org/packages/41/78/96dddb75bb9be730b87c72f30ffdd62611aba234e4e460576a068c98eff6/numpy-2.2.4-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f05d4198c1bacc9124018109c5fba2f3201dbe7ab6e92ff100494f236209c960", size = 14051725 },
-    { url = "https://files.pythonhosted.org/packages/39/41/c5377dac0514aaeec69115830a39d905b1882819c8e65d97fc60e177e19e/numpy-2.2.5-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:55f09e00d4dccd76b179c0f18a44f041e5332fd0e022886ba1c0bbf3ea4a18d0", size = 16121214 },
+    { url = "https://files.pythonhosted.org/packages/00/06/5306b8199bffac2a29d9119c11f457f6c7d41115a335b78d3f86fad4dbe8/numpy-2.2.4-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e2f085ce2e813a50dfd0e01fbfc0c12bbe5d2063d99f8b29da30e544fb6483b8", size = 16101638 },
-    { url = "https://files.pythonhosted.org/packages/db/54/3b9f89a943257bc8e187145c6bc0eb8e3d615655f7b14e9b490b053e8149/numpy-2.2.5-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:02f226baeefa68f7d579e213d0f3493496397d8f1cff5e2b222af274c86a552a", size = 15575788 },
+    { url = "https://files.pythonhosted.org/packages/fa/03/74c5b631ee1ded596945c12027649e6344614144369fd3ec1aaced782882/numpy-2.2.4-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:92bda934a791c01d6d9d8e038363c50918ef7c40601552a58ac84c9613a665bc", size = 15571717 },
-    { url = "https://files.pythonhosted.org/packages/b1/c4/2e407e85df35b29f79945751b8f8e671057a13a376497d7fb2151ba0d290/numpy-2.2.5-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c26843fd58f65da9491165072da2cccc372530681de481ef670dcc8e27cfb066", size = 17893672 },
+    { url = "https://files.pythonhosted.org/packages/cb/dc/4fc7c0283abe0981e3b89f9b332a134e237dd476b0c018e1e21083310c31/numpy-2.2.4-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ee4d528022f4c5ff67332469e10efe06a267e32f4067dc76bb7e2cddf3cd25ff", size = 17879998 },
-    { url = "https://files.pythonhosted.org/packages/29/7e/d0b44e129d038dba453f00d0e29ebd6eaf2f06055d72b95b9947998aca14/numpy-2.2.5-cp313-cp313t-win32.whl", hash = "sha256:1a161c2c79ab30fe4501d5a2bbfe8b162490757cf90b7f05be8b80bc02f7bb8e", size = 6377102 },
+    { url = "https://files.pythonhosted.org/packages/e5/2b/878576190c5cfa29ed896b518cc516aecc7c98a919e20706c12480465f43/numpy-2.2.4-cp313-cp313t-win32.whl", hash = "sha256:05c076d531e9998e7e694c36e8b349969c56eadd2cdcd07242958489d79a7286", size = 6366896 },
-    { url = "https://files.pythonhosted.org/packages/63/be/b85e4aa4bf42c6502851b971f1c326d583fcc68227385f92089cf50a7b45/numpy-2.2.5-cp313-cp313t-win_amd64.whl", hash = "sha256:d403c84991b5ad291d3809bace5e85f4bbf44a04bdc9a88ed2bb1807b3360bb8", size = 12750096 },
+    { url = "https://files.pythonhosted.org/packages/3e/05/eb7eec66b95cf697f08c754ef26c3549d03ebd682819f794cb039574a0a6/numpy-2.2.4-cp313-cp313t-win_amd64.whl", hash = "sha256:188dcbca89834cc2e14eb2f106c96d6d46f200fe0200310fc29089657379c58d", size = 12739119 },
 ]
 
 [[package]]
@@ -313,25 +242,25 @@ wheels = [
 
 [[package]]
 name = "packaging"
-version = "25.0"
+version = "24.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727 }
+sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f", size = 163950 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469 },
+    { url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759", size = 65451 },
 ]
 
 [[package]]
 name = "pdbp"
-version = "1.7.0"
+version = "1.6.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "colorama", marker = "sys_platform == 'win32'" },
     { name = "pygments" },
     { name = "tabcompleter" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a5/7e/c2e6e6a27417ac9d23c1a8534c72f451463c71776cc182272cadaec78f6d/pdbp-1.7.0.tar.gz", hash = "sha256:d0a5b275720c451f5574427e35523aeb61c244f3faf622a80fe03019ef82d380", size = 25481 }
+sdist = { url = "https://files.pythonhosted.org/packages/69/13/80da03638f62facbee76312ca9ee5941c017b080f2e4c6919fd4e87e16e3/pdbp-1.6.1.tar.gz", hash = "sha256:f4041642952a05df89664e166d5bd379607a0866ddd753c06874f65552bdf40b", size = 25322 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/86/2f/1f0144b14553ad32a8d0afa38b832c4b117694484c32aef2d939dc96f20a/pdbp-1.7.0-py3-none-any.whl", hash = "sha256:6ad99cb4e9f2fc1a5b4ef4f2e0acdb28b18b271bf71f6c9f997b652d935caa19", size = 21614 },
+    { url = "https://files.pythonhosted.org/packages/29/93/d56fb9ba5569dc29d8263c72e46d21a2fd38741339ebf03f54cf7561828c/pdbp-1.6.1-py3-none-any.whl", hash = "sha256:f10bad2ee044c0e5c168cb0825abfdbdc01c50013e9755df5261b060bdd35c22", size = 21495 },
 ]
 
 [[package]]
@@ -357,29 +286,14 @@ wheels = [
 
 [[package]]
 name = "prompt-toolkit"
-version = "3.0.51"
+version = "3.0.50"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "wcwidth" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/bb/6e/9d084c929dfe9e3bfe0c6a47e31f78a25c54627d64a66e884a8bf5474f1c/prompt_toolkit-3.0.51.tar.gz", hash = "sha256:931a162e3b27fc90c86f1b48bb1fb2c528c2761475e57c9c06de13311c7b54ed", size = 428940 }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/e1/bd15cb8ffdcfeeb2bdc215de3c3cffca11408d829e4b8416dcfe71ba8854/prompt_toolkit-3.0.50.tar.gz", hash = "sha256:544748f3860a2623ca5cd6d2795e7a14f3d0e1c3c9728359013f79877fc89bab", size = 429087 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ce/4f/5249960887b1fbe561d9ff265496d170b55a735b76724f10ef19f9e40716/prompt_toolkit-3.0.51-py3-none-any.whl", hash = "sha256:52742911fde84e2d423e2f9a4cf1de7d7ac4e51958f648d9540e0fb8db077b07", size = 387810 },
+    { url = "https://files.pythonhosted.org/packages/e4/ea/d836f008d33151c7a1f62caf3d8dd782e4d15f6a43897f64480c2b8de2ad/prompt_toolkit-3.0.50-py3-none-any.whl", hash = "sha256:9b6427eb19e479d98acff65196a307c555eb567989e6d88ebbb1b509d9779198", size = 387816 },
-]
-
-[[package]]
-name = "psutil"
-version = "7.0.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/2a/80/336820c1ad9286a4ded7e845b2eccfcb27851ab8ac6abece774a6ff4d3de/psutil-7.0.0.tar.gz", hash = "sha256:7be9c3eba38beccb6495ea33afd982a44074b78f28c434a1f51cc07fd315c456", size = 497003 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/ed/e6/2d26234410f8b8abdbf891c9da62bee396583f713fb9f3325a4760875d22/psutil-7.0.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:101d71dc322e3cffd7cea0650b09b3d08b8e7c4109dd6809fe452dfd00e58b25", size = 238051 },
-    { url = "https://files.pythonhosted.org/packages/04/8b/30f930733afe425e3cbfc0e1468a30a18942350c1a8816acfade80c005c4/psutil-7.0.0-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:39db632f6bb862eeccf56660871433e111b6ea58f2caea825571951d4b6aa3da", size = 239535 },
-    { url = "https://files.pythonhosted.org/packages/2a/ed/d362e84620dd22876b55389248e522338ed1bf134a5edd3b8231d7207f6d/psutil-7.0.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1fcee592b4c6f146991ca55919ea3d1f8926497a713ed7faaf8225e174581e91", size = 275004 },
-    { url = "https://files.pythonhosted.org/packages/bf/b9/b0eb3f3cbcb734d930fdf839431606844a825b23eaf9a6ab371edac8162c/psutil-7.0.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b1388a4f6875d7e2aff5c4ca1cc16c545ed41dd8bb596cefea80111db353a34", size = 277986 },
-    { url = "https://files.pythonhosted.org/packages/eb/a2/709e0fe2f093556c17fbafda93ac032257242cabcc7ff3369e2cb76a97aa/psutil-7.0.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a5f098451abc2828f7dc6b58d44b532b22f2088f4999a937557b603ce72b1993", size = 279544 },
-    { url = "https://files.pythonhosted.org/packages/50/e6/eecf58810b9d12e6427369784efe814a1eec0f492084ce8eb8f4d89d6d61/psutil-7.0.0-cp37-abi3-win32.whl", hash = "sha256:ba3fcef7523064a6c9da440fc4d6bd07da93ac726b5733c29027d7dc95b39d99", size = 241053 },
-    { url = "https://files.pythonhosted.org/packages/50/1b/6921afe68c74868b4c9fa424dad3be35b095e16687989ebbb50ce4fceb7c/psutil-7.0.0-cp37-abi3-win_amd64.whl", hash = "sha256:4cf3d4eb1aa9b348dec30105c55cd9b7d4629285735a102beb4441e38db90553", size = 244885 },
 ]
 
 [[package]]
@@ -483,7 +397,6 @@ name = "tractor"
 version = "0.1.0a6.dev0"
 source = { editable = "." }
 dependencies = [
-    { name = "bidict" },
     { name = "cffi" },
     { name = "colorlog" },
     { name = "msgspec" },
@@ -496,21 +409,17 @@ dependencies = [
 [package.dev-dependencies]
 dev = [
     { name = "greenback" },
-    { name = "mypy" },
     { name = "numpy" },
     { name = "pexpect" },
     { name = "prompt-toolkit" },
-    { name = "psutil" },
     { name = "pyperclip" },
     { name = "pytest" },
     { name = "stackscope" },
-    { name = "trio-typing" },
     { name = "xonsh" },
 ]
 
 [package.metadata]
 requires-dist = [
-    { name = "bidict", specifier = ">=0.23.1" },
     { name = "cffi", specifier = ">=1.17.1" },
     { name = "colorlog", specifier = ">=6.8.2,<7" },
     { name = "msgspec", specifier = ">=0.19.0" },
@@ -523,15 +432,12 @@ requires-dist = [
 [package.metadata.requires-dev]
 dev = [
     { name = "greenback", specifier = ">=1.2.1,<2" },
-    { name = "mypy", specifier = ">=1.15.0" },
     { name = "numpy", specifier = ">=2.2.4" },
     { name = "pexpect", specifier = ">=4.9.0,<5" },
     { name = "prompt-toolkit", specifier = ">=3.0.50" },
-    { name = "psutil", specifier = ">=7.0.0" },
     { name = "pyperclip", specifier = ">=1.9.0" },
     { name = "pytest", specifier = ">=8.3.5" },
     { name = "stackscope", specifier = ">=0.2.2,<0.3" },
-    { name = "trio-typing", specifier = ">=0.10.0" },
     { name = "xonsh", specifier = ">=0.19.2" },
 ]
 
@@ -549,7 +455,7 @@ wheels = [
 
 [[package]]
 name = "trio"
-version = "0.30.0"
+version = "0.29.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "attrs" },
@@ -559,35 +465,9 @@ dependencies = [
     { name = "sniffio" },
     { name = "sortedcontainers" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/01/c1/68d582b4d3a1c1f8118e18042464bb12a7c1b75d64d75111b297687041e3/trio-0.30.0.tar.gz", hash = "sha256:0781c857c0c81f8f51e0089929a26b5bb63d57f927728a5586f7e36171f064df", size = 593776 }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/47/f62e62a1a6f37909aed0bf8f5d5411e06fa03846cfcb64540cd1180ccc9f/trio-0.29.0.tar.gz", hash = "sha256:ea0d3967159fc130acb6939a0be0e558e364fee26b5deeecc893a6b08c361bdf", size = 588952 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/69/8e/3f6dfda475ecd940e786defe6df6c500734e686c9cd0a0f8ef6821e9b2f2/trio-0.30.0-py3-none-any.whl", hash = "sha256:3bf4f06b8decf8d3cf00af85f40a89824669e2d033bb32469d34840edcfc22a5", size = 499194 },
+    { url = "https://files.pythonhosted.org/packages/c9/55/c4d9bea8b3d7937901958f65124123512419ab0eb73695e5f382521abbfb/trio-0.29.0-py3-none-any.whl", hash = "sha256:d8c463f1a9cc776ff63e331aba44c125f423a5a13c684307e828d930e625ba66", size = 492920 },
-]
-
-[[package]]
-name = "trio-typing"
-version = "0.10.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "async-generator" },
-    { name = "importlib-metadata" },
-    { name = "mypy-extensions" },
-    { name = "packaging" },
-    { name = "trio" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/b5/74/a87aafa40ec3a37089148b859892cbe2eef08d132c816d58a60459be5337/trio-typing-0.10.0.tar.gz", hash = "sha256:065ee684296d52a8ab0e2374666301aec36ee5747ac0e7a61f230250f8907ac3", size = 38747 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/89/ff/9bd795273eb14fac7f6a59d16cc8c4d0948a619a1193d375437c7f50f3eb/trio_typing-0.10.0-py3-none-any.whl", hash = "sha256:6d0e7ec9d837a2fe03591031a172533fbf4a1a95baf369edebfc51d5a49f0264", size = 42224 },
-]
-
-[[package]]
-name = "typing-extensions"
-version = "4.13.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f6/37/23083fcd6e35492953e8d2aaaa68b860eb422b34627b13f2ce3eb6106061/typing_extensions-4.13.2.tar.gz", hash = "sha256:e6c81219bd689f51865d9e372991c540bda33a0379d5573cddb9a3a23f7caaef", size = 106967 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/8b/54/b1ae86c0973cc6f0210b53d508ca3641fb6d0c56823f288d108bc7ab3cc8/typing_extensions-4.13.2-py3-none-any.whl", hash = "sha256:a439e7c04b49fec3e5d3e2beaa21755cadbbdc391694e28ccdd36ca4a1408f8c", size = 45806 },
 ]
 
 [[package]]
@@ -654,22 +534,13 @@ wheels = [
 
 [[package]]
 name = "xonsh"
-version = "0.19.3"
+version = "0.19.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/4a/5a/7d28dffedef266b3cbde5c0ba63f7f861bd5ff5c35bfa80df269f61000b4/xonsh-0.19.3.tar.gz", hash = "sha256:f3a58752b12f02bf2b17b91e88a83615115bb4883032cf8ef36e451964f29e90", size = 801379 }
+sdist = { url = "https://files.pythonhosted.org/packages/68/4e/56e95a5e607eb3b0da37396f87cde70588efc8ef819ab16f02d5b8378dc4/xonsh-0.19.2.tar.gz", hash = "sha256:cfdd0680d954a2c3aefd6caddcc7143a3d06aa417ed18365a08219bb71b960b0", size = 799960 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/fc/66/06310078bec654c792d8f3912c330efe8dbda13867916f4922b6035f3287/xonsh-0.19.3-py310-none-any.whl", hash = "sha256:e0cd36b5a9765aa6f0e5365ac349fd3cbd452cc932d92c754de323dab2a8589a", size = 642609 },
+    { url = "https://files.pythonhosted.org/packages/6c/13/281094759df87b23b3c02dc4a16603ab08ea54d7f6acfeb69f3341137c7a/xonsh-0.19.2-py310-none-any.whl", hash = "sha256:ec7f163fd3a4943782aa34069d4e72793328c916a5975949dbec8536cbfc089b", size = 642301 },
-    { url = "https://files.pythonhosted.org/packages/20/c6/f4924f231a0fdc74f9382ed3e58b2fe6d25c24e3861dde0d30ebec3beecb/xonsh-0.19.3-py311-none-any.whl", hash = "sha256:319f03034a4838041d2326785c1fde3a45c709e825451aa4ff01b803ca452856", size = 642576 },
+    { url = "https://files.pythonhosted.org/packages/29/41/a51e4c3918fe9a293b150cb949b1b8c6d45eb17dfed480dcb76ea43df4e7/xonsh-0.19.2-py311-none-any.whl", hash = "sha256:53c45f7a767901f2f518f9b8dd60fc653e0498e56e89825e1710bb0859985049", size = 642286 },
-    { url = "https://files.pythonhosted.org/packages/82/52/a9de7c31546fc236950aabe22205105eeec8cf30655a522ba9f9397d9352/xonsh-0.19.3-py312-none-any.whl", hash = "sha256:6339c72f3a36cf8022fc6daffb9b97571d3a32f31ef9ff0a41b1d5185724e8d7", size = 642587 },
+    { url = "https://files.pythonhosted.org/packages/0a/93/9a77b731f492fac27c577dea2afb5a2bcc2a6a1c79be0c86c95498060270/xonsh-0.19.2-py312-none-any.whl", hash = "sha256:b24c619aa52b59eae4d35c4195dba9b19a2c548fb5c42c6f85f2b8ccb96807b5", size = 642386 },
-    { url = "https://files.pythonhosted.org/packages/8b/60/bc91e414c75d902816356ec5103adc1fa1672038085b40275a291e149945/xonsh-0.19.3-py313-none-any.whl", hash = "sha256:1b1ca8fee195aab4bef36948aaf7580c2230580b5c0dd7c34a335fb84023efc4", size = 643111 },
+    { url = "https://files.pythonhosted.org/packages/be/75/070324769c1ff88d971ce040f4f486339be98e0a365c8dd9991eb654265b/xonsh-0.19.2-py313-none-any.whl", hash = "sha256:c53ef6c19f781fbc399ed1b382b5c2aac2125010679a3b61d643978273c27df0", size = 642873 },
-    { url = "https://files.pythonhosted.org/packages/b8/b4/7bbf0096e909d332e2e81d0024660dfca69017c56ce43115098e841e1454/xonsh-0.19.3-py39-none-any.whl", hash = "sha256:80e3313fb375d49f0eef2f86375224b568b3cbdd019f63a6bc037117aac1704e", size = 634814 },
+    { url = "https://files.pythonhosted.org/packages/fa/cb/2c7ccec54f5b0e73fdf7650e8336582ff0347d9001c5ef8271dc00c034fe/xonsh-0.19.2-py39-none-any.whl", hash = "sha256:bcc0225dc3847f1ed2f175dac6122fbcc54cea67d9c2dc2753d9615e2a5ff284", size = 634602 },
-]
-
-[[package]]
-name = "zipp"
-version = "3.21.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/3f/50/bad581df71744867e9468ebd0bcd6505de3b275e06f202c2cb016e3ff56f/zipp-3.21.0.tar.gz", hash = "sha256:2c9958f6430a2040341a52eb608ed6dd93ef4392e02ffe219417c1b28b5dd1f4", size = 24545 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b7/1a/7e4798e9339adc931158c9d69ecc34f5e6791489d469f5e50ec15e35f458/zipp-3.21.0-py3-none-any.whl", hash = "sha256:ac1bbe05fd2991f160ebce24ffbac5f6d11d83dc90891255885223d42b3cd931", size = 9630 },
 ]