trio.hazmat > lowlevel

Author: smurfix

docs/source/principles.rst

@@ -81,7 +81,7 @@ Most *synchronous* asyncio or Trio functions (:meth:`trio.Event.set`,
 asyncio or Trio context, and work equally well regardless of the
 flavor of function calling them. The exceptions are functions that
 access the current task (:func:`asyncio.current_task`,
-:func:`trio.hazmat.current_task`, and anything that calls them),
+:func:`trio.lowlevel.current_task`, and anything that calls them),
 because there's only a meaningful concept of the current *foo* task
 when a *foo*-flavored function is executing.  For example, this means
 context managers that set a timeout on their body (``with

tests/interop/test_calls.py

@@ -302,7 +302,7 @@ async def test_asyncio_trio_cancel_out(self, loop):
         async def cancelled_trio(seen):
             seen.flag |= 1
             await trio.sleep(0.01)
-            scope = trio.hazmat.current_task()._cancel_status._scope
+            scope = trio.lowlevel.current_task()._cancel_status._scope
             scope.cancel()
             seen.flag |= 2
             await trio.sleep(0.01)

tests/test_misc.py

@@ -30,7 +30,7 @@ def close_no_stop():
     async def test_too_many_stops(self):
         with trio.move_on_after(1) as scope:
             async with trio_asyncio.open_loop() as loop:
-                await trio.hazmat.checkpoint()
+                await trio.lowlevel.checkpoint()
                 loop.stop()
         assert not scope.cancelled_caught, \
             "Possible deadlock after manual call to loop.stop"

trio_asyncio/_base.py

@@ -17,7 +17,7 @@
 from selectors import _BaseSelectorImpl, EVENT_READ, EVENT_WRITE
 
 try:
-    from trio.hazmat import wait_for_child
+    from trio.lowlevel import wait_for_child
 except ImportError:
     from ._child import wait_for_child
 
@@ -27,11 +27,11 @@
 _mswindows = (sys.platform == "win32")
 
 try:
-    _wait_readable = trio.hazmat.wait_readable
-    _wait_writable = trio.hazmat.wait_writable
+    _wait_readable = trio.lowlevel.wait_readable
+    _wait_writable = trio.lowlevel.wait_writable
 except AttributeError:
-    _wait_readable = trio.hazmat.wait_socket_readable
-    _wait_writable = trio.hazmat.wait_socket_writable
+    _wait_readable = trio.lowlevel.wait_socket_readable
+    _wait_writable = trio.lowlevel.wait_socket_writable
 
 
 class _Clear:
@@ -466,7 +466,7 @@ def add_reader(self, fd, callback, *args):
         ready for reading.
 
         This creates a new Trio task. You may want to use "await
-        :obj:`trio.hazmat.wait_readable` (fd)" instead, or
+        :obj:`trio.lowlevel.wait_readable` (fd)" instead, or
 
         :param fd: Either an integer (Unix file descriptor) or an object
                    with a ``fileno`` method providing one.
@@ -516,7 +516,7 @@ def add_writer(self, fd, callback, *args):
         ready for writing.
 
         This creates a new Trio task. You may want to use "await
-        :obj:`trio.hazmat.wait_writable` (fd) instead, or
+        :obj:`trio.lowlevel.wait_writable` (fd) instead, or
 
         :param fd: Either an integer (Unix file descriptor) or an object
                    with a ``fileno`` method providing one.
@@ -614,8 +614,8 @@ async def _main_loop_init(self, nursery):
         if self._nursery is not None or not self._stopped.is_set():
             raise RuntimeError("You can't enter a loop twice")
         self._nursery = nursery
-        self._task = trio.hazmat.current_task()
-        self._token = trio.hazmat.current_trio_token()
+        self._task = trio.lowlevel.current_task()
+        self._token = trio.lowlevel.current_trio_token()
 
     async def _main_loop(self, task_status=trio.TASK_STATUS_IGNORED):
         """Run the loop by processing its event queue.

trio_asyncio/_child.py

@@ -96,7 +96,7 @@ async def wait(self):
     async def _start_waiting(self):
         """Start the background thread that waits for a specific child"""
         self.__event = trio.Event()
-        self.__token = trio.hazmat.current_trio_token()
+        self.__token = trio.lowlevel.current_trio_token()
 
         self.__thread = threading.Thread(
             target=self._wait_thread, name="waitpid_%d" % self.__pid, daemon=True

trio_asyncio/_loop.py

@@ -18,7 +18,7 @@
 from ._deprecate import deprecated, warn_deprecated
 
 try:
-    from trio.hazmat import wait_for_child
+    from trio.lowlevel import wait_for_child
 except ImportError:
     from ._child import wait_for_child
 
@@ -103,7 +103,7 @@ class _FakedPolicy(threading.local):
 
 def _in_trio_context():
     try:
-        trio.hazmat.current_task()
+        trio.lowlevel.current_task()
     except RuntimeError:
         return False
     else:
@@ -147,7 +147,7 @@ def get_event_loop(self):
         ``.current_event_loop`` property.
         """
         try:
-            task = trio.hazmat.current_task()
+            task = trio.lowlevel.current_task()
         except RuntimeError:
             pass
         else:
@@ -230,7 +230,7 @@ def _new_policy_set(new_policy):
 
     def _new_run_get():
         try:
-            task = trio.hazmat.current_task()
+            task = trio.lowlevel.current_task()
         except RuntimeError:
             pass
         else:

trio_asyncio/_util.py

@@ -23,11 +23,11 @@ async def run_aio_future(future):
     This is a Trio-flavored async function.
 
     """
-    task = trio.hazmat.current_task()
+    task = trio.lowlevel.current_task()
     raise_cancel = None
 
     def done_cb(_):
-        trio.hazmat.reschedule(task, outcome.capture(future.result))
+        trio.lowlevel.reschedule(task, outcome.capture(future.result))
 
     future.add_done_callback(done_cb)
 
@@ -38,10 +38,10 @@ def abort_cb(raise_cancel_arg):
         # Attempt to cancel our future
         future.cancel()
         # Keep waiting
-        return trio.hazmat.Abort.FAILED
+        return trio.lowlevel.Abort.FAILED
 
     try:
-        res = await trio.hazmat.wait_task_rescheduled(abort_cb)
+        res = await trio.lowlevel.wait_task_rescheduled(abort_cb)
         return res
     except asyncio.CancelledError as exc:
         if raise_cancel is not None:
@@ -64,7 +64,7 @@ async def run_aio_generator(loop, async_generator):
     doesn't have to be). The asyncio tasks that perform each iteration
     of *async_generator* will run in *loop*.
     """
-    task = trio.hazmat.current_task()
+    task = trio.lowlevel.current_task()
     raise_cancel = None
     current_read = None
 
@@ -83,7 +83,7 @@ async def consume_next():
         finally:
             sniffio.current_async_library_cvar.reset(t)
 
-        trio.hazmat.reschedule(task, result)
+        trio.lowlevel.reschedule(task, result)
 
     def abort_cb(raise_cancel_arg):
         # Save the cancel-raising function
@@ -92,25 +92,25 @@ def abort_cb(raise_cancel_arg):
 
         if not current_read:
             # There is no current read
-            return trio.hazmat.Abort.SUCCEEDED
+            return trio.lowlevel.Abort.SUCCEEDED
         else:
             # Attempt to cancel the current iterator read, do not
             # report success until the future was actually cancelled.
             already_cancelled = current_read.cancel()
             if already_cancelled:
-                return trio.hazmat.Abort.SUCCEEDED
+                return trio.lowlevel.Abort.SUCCEEDED
             else:
                 # Continue dealing with the cancellation once
                 # future.cancel() goes to the result of
                 # wait_task_rescheduled()
-                return trio.hazmat.Abort.FAILED
+                return trio.lowlevel.Abort.FAILED
 
     try:
         while True:
             # Schedule in asyncio that we read the next item from the iterator
             current_read = asyncio.ensure_future(consume_next(), loop=loop)
 
-            item = await trio.hazmat.wait_task_rescheduled(abort_cb)
+            item = await trio.lowlevel.wait_task_rescheduled(abort_cb)
 
             if item is STOP:
                 break