async-kernel 0.2.0__tar.gz → 0.2.1__tar.gz

{async_kernel-0.2.0 → async_kernel-0.2.1}/.github/workflows/pre-commit.yml

@@ -8,7 +8,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v5
-      - uses: actions/setup-python@v5
+      - uses: actions/setup-python@v6
         with:
           python-version: 3.x
       - uses: pre-commit/action@v3.0.1

{async_kernel-0.2.0 → async_kernel-0.2.1}/CHANGELOG.md

@@ -5,6 +5,36 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.1] - 2025-09-10
+
+### <!-- 0 --> 🏗️ Breaking changes
+
+- Maintenance [#105](https://github.com/fleming79/async-kernel/pull/105)
+
+### <!-- 1 --> 🚀 Features
+
+- Divide Lock into AsyncLock and ReentrantAsyncLock [#113](https://github.com/fleming79/async-kernel/pull/113)
+
+- Improve Lock class [#112](https://github.com/fleming79/async-kernel/pull/112)
+
+- Add a context based Lock [#111](https://github.com/fleming79/async-kernel/pull/111)
+
+- Add classmethod  Caller.wait [#106](https://github.com/fleming79/async-kernel/pull/106)
+
+- Add 'shield' option to Caller.as_completed. [#104](https://github.com/fleming79/async-kernel/pull/104)
+
+### <!-- 6 --> 🌀 Miscellaneous
+
+- Bump actions/setup-python from 5 to 6 in the actions group [#110](https://github.com/fleming79/async-kernel/pull/110)
+
+- Maintenance - Caller refactoring [#109](https://github.com/fleming79/async-kernel/pull/109)
+
+- Drop WaitType for Literals directly in Caller.wait. [#108](https://github.com/fleming79/async-kernel/pull/108)
+
+- Change Caller._queue_map to a WeakKeyDictionary. [#107](https://github.com/fleming79/async-kernel/pull/107)
+
+- Refactor Caller.wait to avoid catching  exceptions. [#103](https://github.com/fleming79/async-kernel/pull/103)
+
 ## [0.2.0] - 2025-09-06
 
 ### <!-- 0 --> 🏗️ Breaking changes
@@ -29,6 +59,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### <!-- 6 --> 🌀 Miscellaneous
 
+- Prepare for release v0.2.0 [#102](https://github.com/fleming79/async-kernel/pull/102)
+
 - Result should raise cancelled error, but was raising and InvalidStateError. [#98](https://github.com/fleming79/async-kernel/pull/98)
 
 ## [0.1.4] - 2025-09-03
@@ -207,6 +239,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Bump the actions group across 1 directory with 2 updates [#3](https://github.com/fleming79/async-kernel/pull/3)
 
+[0.2.1]: https://github.com/fleming79/async-kernel/compare/v0.2.0..v0.2.1
 [0.2.0]: https://github.com/fleming79/async-kernel/compare/v0.1.4..v0.2.0
 [0.1.4]: https://github.com/fleming79/async-kernel/compare/v0.1.3..v0.1.4
 [0.1.3]: https://github.com/fleming79/async-kernel/compare/v0.1.2..v0.1.3

{async_kernel-0.2.0 → async_kernel-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: async-kernel
-Version: 0.2.0
+Version: 0.2.1
 Summary: A concurrent python kernel for Jupyter supporting AnyIO, AsyncIO and Trio.
 Project-URL: Homepage, https://fleming79.github.io/async-kernel
 Project-URL: Documentation, https://fleming79.github.io/async-kernel

{async_kernel-0.2.0 → async_kernel-0.2.1}/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.2.0'
-__version_tuple__ = version_tuple = (0, 2, 0)
+__version__ = version = '0.2.1'
+__version_tuple__ = version_tuple = (0, 2, 1)
 
 __commit_id__ = commit_id = None

{async_kernel-0.2.0 → async_kernel-0.2.1}/src/async_kernel/caller.py

@@ -14,6 +14,7 @@ from typing import TYPE_CHECKING, Any, ClassVar, Literal, Self, cast, overload
 
 import anyio
 import sniffio
+from anyio.streams.memory import MemoryObjectSendStream
 from typing_extensions import override
 from zmq import Context, Socket, SocketType
 
@@ -32,7 +33,7 @@ if TYPE_CHECKING:
 
     from async_kernel.typing import P
 
-__all__ = ["Caller", "Future", "FutureCancelledError", "InvalidStateError"]
+__all__ = ["AsyncLock", "Caller", "Future", "FutureCancelledError", "InvalidStateError", "ReentrantAsyncLock"]
 
 
 class FutureCancelledError(anyio.ClosedResourceError):
@@ -132,23 +133,22 @@ class Future(Awaitable[T]):
 
         Args:
             timeout: Timeout in seconds.
-            shield: Shield cancellation.
+            shield: Shield the future from cancellation.
             result: Whether the result should be returned.
         """
-        if not self._event_done.is_set():
-            with anyio.fail_after(delay=timeout):
-                try:
+        try:
+            if not self.done():
+                with anyio.fail_after(timeout):
                     if threading.current_thread() is self.thread:
                         if not self._anyio_event_done:
                             self._anyio_event_done = anyio.Event()
                         await self._anyio_event_done.wait()
                     else:
                         await wait_thread_event(self._event_done)
-                except BaseException as e:
-                    if not shield:
-                        self.cancel(str(e))
-                    raise
-        return self.result() if result else None
+            return self.result() if result else None
+        finally:
+            if not self.done() and not shield:
+                self.cancel("Cancelled with waiter cancellation.")
 
     if TYPE_CHECKING:
 
@@ -306,10 +306,11 @@ class Caller:
     _outstanding = 0
     _to_thread_pool: ClassVar[deque[Self]] = deque()
     _pool_instances: ClassVar[weakref.WeakSet[Self]] = weakref.WeakSet()
-    _executor_queue: dict
+    _queue_map: weakref.WeakKeyDictionary[Callable[..., Awaitable[Any]], MemoryObjectSendStream[tuple]]
     _taskgroup: TaskGroup | None = None
     _callers: deque[tuple[contextvars.Context, tuple[Future, float, float, Callable, tuple, dict]] | Callable[[], Any]]
     _callers_added: threading.Event
+    _stopped_event: threading.Event
     _stopped = False
     _protected = False
     _running = False
@@ -367,7 +368,7 @@ class Caller:
             inst._callers = deque()
             inst._callers_added = threading.Event()
             inst._protected = protected
-            inst._executor_queue = {}
+            inst._queue_map = weakref.WeakKeyDictionary()
             cls._instances[thread] = inst
         return inst
 
@@ -376,9 +377,9 @@ class Caller:
         return f"Caller<{self.thread.name}>"
 
     async def __aenter__(self) -> Self:
-        self._cancelled_exception_class = anyio.get_cancelled_exc_class()
         async with contextlib.AsyncExitStack() as stack:
             self._running = True
+            self._stopped_event = threading.Event()
             self._taskgroup = tg = await stack.enter_async_context(anyio.create_task_group())
             await tg.start(self._server_loop, tg)
             self.__stack = stack.pop_all()
@@ -386,7 +387,7 @@ class Caller:
 
     async def __aexit__(self, exc_type, exc_value, exc_tb) -> None:
         if self.__stack is not None:
-            self.stop()
+            self.stop(force=True)
             await self.__stack.__aexit__(exc_type, exc_value, exc_tb)
 
     async def _server_loop(self, tg: TaskGroup, task_status: TaskStatus[None]) -> None:
@@ -397,7 +398,12 @@ class Caller:
             self.iopub_sockets[self.thread] = socket
             task_status.started()
             while not self._stopped:
-                while len(self._callers):
+                if not self._callers:
+                    self._callers_added.clear()
+                await wait_thread_event(self._callers_added)
+                while self._callers:
+                    if self._stopped:
+                        return
                     job = self._callers.popleft()
                     if isinstance(job, Callable):
                         try:
@@ -407,8 +413,6 @@ class Caller:
                     else:
                         context, args = job
                         context.run(tg.start_soon, self._wrap_call, *args)
-                    self._callers_added.clear()
-                await wait_thread_event(self._callers_added)
         finally:
             self._running = False
             for job in self._callers:
@@ -416,6 +420,7 @@ class Caller:
                     job[1][0].set_exception(FutureCancelledError())
             socket.close()
             self.iopub_sockets.pop(self.thread, None)
+            self._stopped_event.set()
             tg.cancel_scope.cancel()
 
     async def _wrap_call(
@@ -442,12 +447,9 @@ class Caller:
                         result: T = await result
                     if fut.cancelled() and not scope.cancel_called:
                         scope.cancel()
-                    if scope.cancel_called:
-                        # await here to allow the cancel scope to be raised/caught.
-                        await anyio.sleep(0)
                     self._outstanding -= 1  # update first for _to_thread_on_done
                     fut.set_result(result)
-                except self._cancelled_exception_class:
+                except anyio.get_cancelled_exc_class():
                     fut.cancel()
                     self._outstanding -= 1  # update first for _to_thread_on_done
                     fut.set_result(cast("T", None))  # This will cancel
@@ -493,13 +495,18 @@ class Caller:
         if self._protected and not force:
             return
         self._stopped = True
+        for sender in self._queue_map.values():
+            sender.close()
+        self._queue_map.clear()
         self._callers_added.set()
         self._instances.pop(self.thread, None)
         if self in self._to_thread_pool:
             self._to_thread_pool.remove(self)
+        if self.thread is not threading.current_thread():
+            self._stopped_event.wait()
 
     def call_later(
-        self, func: Callable[P, T | Awaitable[T]], delay: float = 0.0, /, *args: P.args, **kwargs: P.kwargs
+        self, delay: float, func: Callable[P, T | Awaitable[T]], /, *args: P.args, **kwargs: P.kwargs
     ) -> Future[T]:
         """
         Schedule func to be called in caller's event loop copying the current context.
@@ -530,7 +537,7 @@ class Caller:
             *args: Arguments to use with func.
             **kwargs: Keyword arguments to use with func.
         """
-        return self.call_later(func, 0.0, *args, **kwargs)
+        return self.call_later(0, func, *args, **kwargs)
 
     def call_direct(self, func: Callable[P, Any], /, *args: P.args, **kwargs: P.kwargs) -> None:
         """
@@ -550,9 +557,9 @@ class Caller:
         self._callers.append(functools.partial(func, *args, **kwargs))
         self._callers_added.set()
 
-    def has_execution_queue(self, func: Callable) -> bool:
+    def queue_exists(self, func: Callable) -> bool:
         "Returns True if an execution queue exists for `func`."
-        return func in self._executor_queue
+        return func in self._queue_map
 
     if TYPE_CHECKING:
 
@@ -563,7 +570,7 @@ class Caller:
             /,
             *args: *PosArgsT,
             max_buffer_size: NoValue | int = NoValue,  # pyright: ignore[reportInvalidTypeForm]
-            send_nowait: Literal[False],
+            wait: Literal[True],
         ) -> CoroutineType[Any, Any, None]: ...
         @overload
         def queue_call(
@@ -572,7 +579,7 @@ class Caller:
             /,
             *args: *PosArgsT,
             max_buffer_size: NoValue | int = NoValue,  # pyright: ignore[reportInvalidTypeForm]
-            send_nowait: Literal[True] | Any = True,
+            wait: Literal[False] | Any = False,
         ) -> None: ...
 
     def queue_call(
@@ -581,10 +588,10 @@ class Caller:
         /,
         *args: *PosArgsT,
         max_buffer_size: NoValue | int = NoValue,  # pyright: ignore[reportInvalidTypeForm]
-        send_nowait: bool = True,
+        wait: bool = False,
     ) -> CoroutineType[Any, Any, None] | None:
         """
-        Queue the execution of func in queue specific to the function (not thread-safe).
+        Queue the execution of `func` with the arguments `*args` in a queue unique to it (not thread-safe).
 
         The args are added to a queue associated with the provided `func`. If queue does not already exist for
         func, a new queue is created with a specified maximum buffer size. The arguments are then sent to the queue,
@@ -595,11 +602,19 @@ class Caller:
             func: The asynchronous function to execute.
             *args: The arguments to pass to the function.
             max_buffer_size: The maximum buffer size for the queue. If NoValue, defaults to [async_kernel.Caller.MAX_BUFFER_SIZE].
-            send_nowait: Set as False to return a coroutine that is used to send the request.
+            wait: Set as True to return a coroutine that will return once the request is sent.
                 Use this to prevent experiencing exceptions if the buffer is full.
+
+        !!! info
+
+            The queue will stay open until one of the following occurs.
+
+            1. It explicitly closed with the method `queue_close`.
+            1. All strong references are lost the function/method.
+
         """
         self._check_in_thread()
-        if not self.has_execution_queue(func):
+        if not (sender := self._queue_map.get(func)):
             max_buffer_size = self.MAX_BUFFER_SIZE if max_buffer_size is NoValue else max_buffer_size
             sender, queue = anyio.create_memory_object_stream[tuple[*PosArgsT]](max_buffer_size=max_buffer_size)
 
@@ -608,38 +623,28 @@ class Caller:
                     with contextlib.suppress(anyio.get_cancelled_exc_class()):
                         async with queue as receive_stream:
                             async for args in receive_stream:
+                                if func not in self._queue_map:
+                                    break
                                 try:
                                     await func(*args)
                                 except Exception as e:
                                     self.log.exception("Execution %f failed", func, exc_info=e)
                 finally:
-                    self._executor_queue.pop(execute_loop, None)
+                    self._queue_map.pop(func, None)
 
-            self._executor_queue[func] = {"queue": sender, "future": self.call_soon(execute_loop)}
-        sender: MemoryObjectSendStream[tuple[*PosArgsT]] = self._executor_queue[func]["queue"]
-        return sender.send_nowait(args) if send_nowait else sender.send(args)
+            self._queue_map[func] = sender
+            self.call_soon(execute_loop)
+        return sender.send(args) if wait else sender.send_nowait(args)
 
-    async def queue_close(self, func: Callable, *, force: bool = False) -> bool:
+    def queue_close(self, func: Callable) -> None:
         """
-        Close the execution queue associated with func (not thread-safe).
+        Close the execution queue associated with func (thread-safe).
 
         Args:
             func: The queue of the function to close.
-            force: Shutdown without waiting pending tasks to complete.
-
-        Returns:
-            True if a queue was closed.
         """
-        self._check_in_thread()
-        if queue_map := self._executor_queue.pop(func, None):
-            if force:
-                queue_map["future"].cancel()
-            else:
-                await queue_map["queue"].aclose()
-            with contextlib.suppress(FutureCancelledError):
-                await queue_map["future"]
-            return True
-        return False
+        if sender := self._queue_map.pop(func, None):
+            self.call_direct(sender.close)
 
     @classmethod
     def stop_all(cls, *, _stop_protected: bool = False) -> None:
@@ -756,12 +761,23 @@ class Caller:
         """A classmethod that returns the current future when called from inside a function scheduled by Caller."""
         return cls._future_var.get()
 
+    @classmethod
+    def all_callers(cls, running_only: bool = True) -> list[Caller]:
+        """
+        A classmethod to get a list of the callers.
+
+        Args:
+            running_only: Restrict the list to callers that are active (running in an async context).
+        """
+        return [caller for caller in Caller._instances.values() if caller._running or not running_only]
+
     @classmethod
     async def as_completed(
         cls,
         items: Iterable[Future[T]] | AsyncGenerator[Future[T]],
         *,
         max_concurrent: NoValue | int = NoValue,  # pyright: ignore[reportInvalidTypeForm]
+        shield: bool = False,
     ) -> AsyncGenerator[Future[T], Any]:
         """
         A classmethod iterator to get [Futures][async_kernel.caller.Future] as they complete.
@@ -771,6 +787,7 @@ class Caller:
             max_concurrent: The maximum number of concurrent futures to monitor at a time.
                 This is useful when `items` is a generator utilising Caller.to_thread.
                 By default this will limit to `Caller.MAX_IDLE_POOL_INSTANCES`.
+            shield: Shield existing items from cancellation.
 
         !!! tip
 
@@ -782,62 +799,216 @@ class Caller:
         futures: set[Future[T]] = set()
         done = False
         resume: Event | None = cast("anyio.Event | None", None)
+        current_future = cls.current_future()
+        if isinstance(items, set | list | tuple):
+            max_concurrent_ = 0
+        else:
+            max_concurrent_ = cls.MAX_IDLE_POOL_INSTANCES if max_concurrent is NoValue else int(max_concurrent)
 
         def _on_done(fut: Future[T]) -> None:
             has_result.append(fut)
             event_future_ready.set()
 
-        async def iter_items(task_status: TaskStatus[None]):
+        async def iter_items():
             nonlocal done, resume
-            if isinstance(items, set | list | tuple):
-                max_concurrent_ = 0
-            else:
-                max_concurrent_ = cls.MAX_IDLE_POOL_INSTANCES if max_concurrent is NoValue else int(max_concurrent)
-
             gen = items if isinstance(items, AsyncGenerator) else iter(items)
-            task_status.started()
             try:
                 while True:
                     fut = await anext(gen) if isinstance(gen, AsyncGenerator) else next(gen)
-                    futures.add(fut)
-                    if fut.done():
-                        has_result.append(fut)
-                        event_future_ready.set()
-                    else:
-                        fut.add_done_callback(_on_done)
-                    if max_concurrent_ and len(futures) == max_concurrent_:
-                        resume = anyio.Event()
-                        await resume.wait()
+                    if fut is not current_future:
+                        futures.add(fut)
+                        if fut.done():
+                            has_result.append(fut)
+                            event_future_ready.set()
+                        else:
+                            fut.add_done_callback(_on_done)
+                        if max_concurrent_ and len(futures) == max_concurrent_:
+                            resume = anyio.Event()
+                            await resume.wait()
             except (StopAsyncIteration, StopIteration):
                 return
             finally:
                 done = True
                 event_future_ready.set()
 
+        fut = cls().call_soon(iter_items)
         try:
-            async with anyio.create_task_group() as tg:
-                await tg.start(iter_items)
-                while futures or not done:
-                    if has_result:
-                        event_future_ready.clear()
-                        fut = has_result.popleft()
-                        futures.discard(fut)
-                        yield fut
-                        if resume:
-                            resume.set()
-                        continue
-                    if not has_result:
-                        await wait_thread_event(event_future_ready)
+            while futures or not done:
+                if has_result:
+                    event_future_ready.clear()
+                    fut = has_result.popleft()
+                    futures.discard(fut)
+                    yield fut
+                    if resume:
+                        resume.set()
+                else:
+                    await wait_thread_event(event_future_ready)
         finally:
+            fut.cancel()
             for fut in futures:
-                fut.cancel()
+                fut.remove_done_callback(_on_done)
+                if not shield:
+                    fut.cancel("Cancelled by as_completed")
 
     @classmethod
-    def all_callers(cls, running_only: bool = True) -> list[Caller]:
+    async def wait(
+        cls,
+        items: Iterable[Future[T]],
+        *,
+        timeout: float | None = None,
+        return_when: Literal["FIRST_COMPLETED", "FIRST_EXCEPTION", "ALL_COMPLETED"] = "ALL_COMPLETED",
+    ) -> tuple[set[T], set[Future[T]]]:
         """
-        A classmethod to get a list of the callers.
+        A classmethod to wait for the futures given by items to complete.
 
-        Args:
-            running_only: Restrict the list to callers that are active (running in an async context).
+        Returns two sets of the futures: (done, pending).
+
+        !!! example
+
+            ```python
+            done, pending = await asyncio.wait(items)
+            ```
+
+        !!! info
+
+            - This does not raise a TimeoutError!
+            - Futures that aren't done when the timeout occurs are returned in the second set.
         """
-        return [caller for caller in Caller._instances.values() if caller._running or not running_only]
+        done = set()
+        if pending := set(items):
+            with anyio.move_on_after(timeout):
+                async for fut in cls.as_completed(items, shield=True):
+                    pending.discard(fut)
+                    done.add(fut)
+                    if return_when == "FIRST_COMPLETED":
+                        break
+                    if return_when == "FIRST_EXCEPTION" and (fut.cancelled() or fut.exception()):
+                        break
+        return done, pending
+
+
+class AsyncLock:
+    """
+    Implements a mutex asynchronous lock that is compatible with [async_kernel.caller.Caller][].
+
+    !!! note
+
+        - Attempting to lock a 'mutuex' configured lock that is *locked* will raise a [RuntimeError][].
+    """
+
+    _reentrant: ClassVar[bool] = False
+    _count: int = 0
+    _ctx_count: int = 0
+    _ctx_current: int = 0
+    _releasing: bool = False
+
+    def __init__(self):
+        self._ctx_var: contextvars.ContextVar[int] = contextvars.ContextVar(f"Lock:{id(self)}", default=0)
+        self._queue: deque[tuple[int, Future[Future | None]]] = deque()
+
+    @override
+    def __repr__(self) -> str:
+        info = f"🔒{self.count}" if self.count else "🔓"
+        return f"{self.__class__.__name__}({info})"
+
+    async def __aenter__(self) -> Self:
+        return await self.acquire()
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:
+        await self.release()
+
+    @property
+    def count(self) -> int:
+        "Returns the number of times the locked context has been entered."
+        return self._count
+
+    async def acquire(self) -> Self:
+        """
+        Acquire a lock.
+
+        If the lock is reentrant the internal counter increments to share the lock.
+        """
+        if not self._reentrant and self.is_in_context():
+            msg = "Already locked and not reentrant!"
+            raise RuntimeError(msg)
+        # Get the context.
+        if not self._reentrant or not (ctx := self._ctx_var.get()):
+            self._ctx_count = ctx = self._ctx_count + 1
+            self._ctx_var.set(ctx)
+        # Check if we can lock or re-enter an active lock.
+        if (not self._releasing) and ((not self.count) or (self._reentrant and self.is_in_context())):
+            self._count += 1
+            self._ctx_current = ctx
+            return self
+        # Join the queue.
+        k: tuple[int, Future[None | Future[Future[None] | None]]] = ctx, Future()
+        self._queue.append(k)
+        try:
+            fut = await k[1]
+        finally:
+            if k in self._queue:
+                self._queue.remove(k)
+        if fut:
+            self._ctx_current = ctx
+            fut.set_result(None)
+            if self._reentrant:
+                for k in tuple(self._queue):
+                    if k[0] == ctx:
+                        self._queue.remove(k)
+                        k[1].set_result(None)
+                        self._count += 1
+            self._releasing = False
+        return self
+
+    async def release(self) -> None:
+        """
+        Decrement the internal counter.
+
+        If the current depth==1 the lock will be passed to the next queued or released if there isn't one.
+        """
+        if not self.is_in_context():
+            raise InvalidStateError
+        if self._count == 1 and self._queue and not self._releasing:
+            self._releasing = True
+            self._ctx_var.set(0)
+            try:
+                fut = Future()
+                k = self._queue.popleft()
+                k[1].set_result(fut)
+                await k[1]
+            except Exception:
+                self._releasing = False
+        else:
+            self._count -= 1
+        if self._count == 0:
+            self._ctx_current = 0
+
+    def is_in_context(self) -> bool:
+        "Returns `True` if the current context has the lock."
+        return bool(self._count and self._ctx_current and (self._ctx_var.get() == self._ctx_current))
+
+
+class ReentrantAsyncLock(AsyncLock):
+    """
+    Implements a Reentrant asynchronous lock compatible with [async_kernel.caller.Caller][].
+
+
+    !!! example
+
+        ```python
+        # Inside a coroutine running inside a thread where a [asyncio.caller.Caller][] instance is running.
+
+        lock = ReentrantAsyncLock(reentrant=True)  # a reentrant lock
+        async with lock:
+            async with lock:
+                Caller().to_thread(...)  # The lock is shared with the thread.
+        ```
+
+    !!! note
+
+        - The lock context can be exitied in any order.
+        - A 'reentrant' lock can *release* control to another context and then re-enter later for
+            tasks or threads called from a locked thread maintaining the same reentrant context.
+    """
+
+    _reentrant: ClassVar[bool] = True