pulse-framework 0.1.64__py3-none-any.whl → 0.1.65__py3-none-any.whl

pulse/render_session.py

@@ -3,11 +3,10 @@ import logging
 import traceback
 import uuid
 from asyncio import iscoroutine
-from collections.abc import Callable
+from collections.abc import Awaitable, Callable
 from typing import TYPE_CHECKING, Any, Literal, TypeVar, overload
 
 from pulse.context import PulseContext
-from pulse.helpers import create_future_on_loop, create_task, later
 from pulse.hooks.runtime import NotFoundInterrupt, RedirectInterrupt
 from pulse.messages import (
 	ServerApiCallMessage,
@@ -29,13 +28,19 @@ from pulse.routing import (
 	RouteTree,
 	ensure_absolute_path,
 )
+from pulse.scheduling import (
+	TaskRegistry,
+	TimerHandleLike,
+	TimerRegistry,
+	create_future,
+)
 from pulse.state import State
 from pulse.transpiler.id import next_id
 from pulse.transpiler.nodes import Expr
 
 if TYPE_CHECKING:
 	from pulse.channel import ChannelsManager
-	from pulse.form import FormRegistry
+	from pulse.forms import FormRegistry
 
 logger = logging.getLogger(__file__)
 
@@ -93,7 +98,7 @@ class RouteMount:
 	state: MountState
 	pending_action: PendingAction | None
 	queue: list[ServerMessage] | None
-	queue_timeout: asyncio.TimerHandle | None
+	queue_timeout: TimerHandleLike | None
 	render_batch_id: int
 	render_batch_renders: int
 
@@ -124,6 +129,7 @@ class RouteMount:
 	def _cancel_pending_timeout(self) -> None:
 		if self.queue_timeout is not None:
 			self.queue_timeout.cancel()
+			self.render.discard_timer(self.queue_timeout)
 			self.queue_timeout = None
 		self.pending_action = None
 
@@ -145,7 +151,9 @@ class RouteMount:
 			)
 			self._cancel_pending_timeout()
 			self.pending_action = next_action
-			self.queue_timeout = later(timeout, self._on_pending_timeout)
+			self.queue_timeout = self.render.schedule_later(
+				timeout, self._on_pending_timeout
+			)
 			return
 		self._cancel_pending_timeout()
 		if self.state == "idle" and self.effect:
@@ -153,7 +161,9 @@ class RouteMount:
 		self.state = "pending"
 		self.queue = []
 		self.pending_action = action
-		self.queue_timeout = later(timeout, self._on_pending_timeout)
+		self.queue_timeout = self.render.schedule_later(
+			timeout, self._on_pending_timeout
+		)
 
 	def activate(self, send_message: Callable[[ServerMessage], Any]) -> None:
 		if self.state != "pending":
@@ -248,6 +258,8 @@ class RenderSession:
 	_pending_api: dict[str, asyncio.Future[dict[str, Any]]]
 	_pending_js_results: dict[str, asyncio.Future[Any]]
 	_global_states: dict[str, State]
+	_tasks: TaskRegistry
+	_timers: TimerRegistry
 
 	def __init__(
 		self,
@@ -262,7 +274,7 @@ class RenderSession:
 		render_loop_limit: int = 50,
 	) -> None:
 		from pulse.channel import ChannelsManager
-		from pulse.form import FormRegistry
+		from pulse.forms import FormRegistry
 
 		self.id = id
 		self.routes = routes
@@ -277,6 +289,8 @@ class RenderSession:
 		self.forms = FormRegistry(self)
 		self._pending_api = {}
 		self._pending_js_results = {}
+		self._tasks = TaskRegistry(name=f"render:{id}")
+		self._timers = TimerRegistry(tasks=self._tasks, name=f"render:{id}")
 		self.prerender_queue_timeout = prerender_queue_timeout
 		self.detach_queue_timeout = detach_queue_timeout
 		self.disconnect_queue_timeout = disconnect_queue_timeout
@@ -427,6 +441,7 @@ class RenderSession:
 
 		if mount is None or mount.state == "idle":
 			# Initial render must come from prerender
+			print(f"[DEBUG] Missing or idle route '{path}', reloading")
 			self.send({"type": "reload"})
 			return
 
@@ -546,9 +561,12 @@ class RenderSession:
 
 	def close(self):
 		self.forms.dispose()
+		self._tasks.cancel_all()
+		self._timers.cancel_all()
 		for path in list(self.route_mounts.keys()):
 			self.detach(path, timeout=0)
 		self.route_mounts.clear()
+		self.query_store.dispose_all()
 		for value in self._global_states.values():
 			value.dispose()
 		self._global_states.clear()
@@ -587,6 +605,28 @@ class RenderSession:
 		with PulseContext.update(render=self):
 			flush_effects()
 
+	def create_task(
+		self,
+		coroutine: Callable[[], Any] | Awaitable[Any],
+		*,
+		name: str | None = None,
+		on_done: Callable[[asyncio.Task[Any]], None] | None = None,
+	) -> asyncio.Task[Any]:
+		"""Create a tracked task tied to this render session."""
+		if callable(coroutine):
+			return self._tasks.create_task(coroutine(), name=name, on_done=on_done)
+		return self._tasks.create_task(coroutine, name=name, on_done=on_done)
+
+	def schedule_later(
+		self, delay: float, fn: Callable[..., Any], *args: Any, **kwargs: Any
+	) -> TimerHandleLike:
+		"""Schedule a tracked timer tied to this render session."""
+		return self._timers.later(delay, fn, *args, **kwargs)
+
+	def discard_timer(self, handle: TimerHandleLike | None) -> None:
+		"""Remove a timer handle from the session registry."""
+		self._timers.discard(handle)
+
 	def execute_callback(self, path: str, key: str, args: list[Any] | tuple[Any, ...]):
 		mount = self.route_mounts[path]
 		cb = mount.tree.callbacks[key]
@@ -598,9 +638,18 @@ class RenderSession:
 			with PulseContext.update(render=self, route=mount.route):
 				res = cb.fn(*args[: cb.n_args])
 				if iscoroutine(res):
-					create_task(
-						res, on_done=lambda t: (e := t.exception()) and report(e, True)
-					)
+
+					def _on_done(t: asyncio.Task[Any]) -> None:
+						if t.cancelled():
+							return
+						try:
+							exc = t.exception()
+						except asyncio.CancelledError:
+							return
+						if exc:
+							report(exc, True)
+
+					self.create_task(res, name=f"callback:{key}", on_done=_on_done)
 		except Exception as e:
 			report(e)
 
@@ -628,7 +677,7 @@ class RenderSession:
 			api_path = url_or_path if url_or_path.startswith("/") else "/" + url_or_path
 			url = f"{base}{api_path}"
 		corr_id = uuid.uuid4().hex
-		fut = create_future_on_loop()
+		fut = create_future()
 		self._pending_api[corr_id] = fut
 		headers = headers or {}
 		headers["x-pulse-render-id"] = self.id
@@ -746,7 +795,7 @@ class RenderSession:
 				if not future.done():
 					future.set_exception(asyncio.TimeoutError())
 
-			loop.call_later(timeout, _on_timeout)
+			self._timers.later(timeout, _on_timeout)
 
 			return future
 

pulse/scheduling.py

@@ -0,0 +1,448 @@
+import asyncio
+import os
+from collections.abc import Awaitable, Callable
+from typing import Any, ParamSpec, Protocol, TypeVar, override
+
+from anyio import from_thread
+
+T = TypeVar("T")
+P = ParamSpec("P")
+
+
+class TimerHandleLike(Protocol):
+	def cancel(self) -> None: ...
+	def cancelled(self) -> bool: ...
+	def when(self) -> float: ...
+
+
+def is_pytest() -> bool:
+	"""Detect if running inside pytest using environment variables."""
+	return bool(os.environ.get("PYTEST_CURRENT_TEST")) or (
+		"PYTEST_XDIST_TESTRUNUID" in os.environ
+	)
+
+
+def _resolve_registries() -> tuple["TaskRegistry", "TimerRegistry"]:
+	from pulse.context import PulseContext
+
+	ctx = PulseContext.get()
+	if ctx.render is not None:
+		return ctx.render._tasks, ctx.render._timers  # pyright: ignore[reportPrivateUsage]
+	return ctx.app._tasks, ctx.app._timers  # pyright: ignore[reportPrivateUsage]
+
+
+def call_soon(
+	fn: Callable[P, Any], *args: P.args, **kwargs: P.kwargs
+) -> TimerHandleLike | None:
+	"""Schedule a callback to run ASAP on the main event loop from any thread."""
+	_, timer_registry = _resolve_registries()
+	return timer_registry.call_soon(fn, *args, **kwargs)
+
+
+def create_task(
+	coroutine: Awaitable[T],
+	*,
+	name: str | None = None,
+	on_done: Callable[[asyncio.Task[T]], None] | None = None,
+) -> asyncio.Task[T]:
+	"""Create a tracked task on the active session/app registry."""
+	task_registry, _ = _resolve_registries()
+	return task_registry.create_task(coroutine, name=name, on_done=on_done)
+
+
+def create_future() -> asyncio.Future[Any]:
+	"""Create an asyncio Future on the main event loop from any thread."""
+	task_registry, _ = _resolve_registries()
+	return task_registry.create_future()
+
+
+def later(
+	delay: float, fn: Callable[P, Any], *args: P.args, **kwargs: P.kwargs
+) -> TimerHandleLike:
+	"""
+	Schedule `fn(*args, **kwargs)` to run after `delay` seconds.
+	Works with sync or async functions. Returns a handle; call .cancel() to cancel.
+
+	The callback runs with no reactive scope to avoid accidentally capturing
+	reactive dependencies from the calling context. Other context vars (like
+	PulseContext) are preserved normally.
+	"""
+
+	_, timer_registry = _resolve_registries()
+	return timer_registry.later(delay, fn, *args, **kwargs)
+
+
+class RepeatHandle:
+	task: asyncio.Task[None] | None
+	cancelled: bool
+
+	def __init__(self) -> None:
+		self.task = None
+		self.cancelled = False
+
+	def cancel(self):
+		if self.cancelled:
+			return
+		self.cancelled = True
+		if self.task is not None and not self.task.done():
+			self.task.cancel()
+
+
+def repeat(interval: float, fn: Callable[P, Any], *args: P.args, **kwargs: P.kwargs):
+	"""
+	Repeatedly run `fn(*args, **kwargs)` every `interval` seconds.
+	Works with sync or async functions.
+	For async functions, waits for completion before starting the next delay.
+	Returns a handle with .cancel() to stop future runs.
+
+	The callback runs with no reactive scope to avoid accidentally capturing
+	reactive dependencies from the calling context. Other context vars (like
+	PulseContext) are preserved normally.
+
+	Optional kwargs:
+	- immediate: bool = False  # run once immediately before the first interval
+	"""
+
+	_, timer_registry = _resolve_registries()
+	return timer_registry.repeat(interval, fn, *args, **kwargs)
+
+
+class TaskRegistry:
+	_tasks: set[asyncio.Task[Any]]
+	name: str | None
+
+	def __init__(self, name: str | None = None) -> None:
+		self._tasks = set()
+		self.name = name
+
+	def track(self, task: asyncio.Task[T]) -> asyncio.Task[T]:
+		self._tasks.add(task)
+		task.add_done_callback(self._tasks.discard)
+		return task
+
+	def create_task(
+		self,
+		coroutine: Awaitable[T],
+		*,
+		name: str | None = None,
+		on_done: Callable[[asyncio.Task[T]], None] | None = None,
+	) -> asyncio.Task[T]:
+		"""Create and schedule a coroutine task on the main loop from any thread."""
+		try:
+			asyncio.get_running_loop()
+			task = asyncio.ensure_future(coroutine)
+			if name is not None:
+				task.set_name(name)
+			if on_done:
+				task.add_done_callback(on_done)
+		except RuntimeError:
+
+			async def _runner():
+				asyncio.get_running_loop()
+				task = asyncio.ensure_future(coroutine)
+				if name is not None:
+					task.set_name(name)
+				if on_done:
+					task.add_done_callback(on_done)
+				return task
+
+			task = from_thread.run(_runner)
+
+		return self.track(task)
+
+	def create_future(self) -> asyncio.Future[Any]:
+		"""Create an asyncio Future on the main event loop from any thread."""
+		try:
+			return asyncio.get_running_loop().create_future()
+		except RuntimeError:
+
+			async def _create():
+				return asyncio.get_running_loop().create_future()
+
+			return from_thread.run(_create)
+
+	def cancel_all(self) -> None:
+		for task in list(self._tasks):
+			if not task.done():
+				task.cancel()
+		self._tasks.clear()
+
+
+class TimerRegistry:
+	_handles: set[TimerHandleLike]
+	_tasks: TaskRegistry
+	name: str | None
+
+	def __init__(self, *, tasks: TaskRegistry, name: str | None = None) -> None:
+		self._handles = set()
+		self._tasks = tasks
+		self.name = name
+
+	def track(self, handle: TimerHandleLike) -> TimerHandleLike:
+		self._handles.add(handle)
+		return handle
+
+	def discard(self, handle: TimerHandleLike | None) -> None:
+		if handle is None:
+			return
+		self._handles.discard(handle)
+
+	def later(
+		self,
+		delay: float,
+		fn: Callable[P, Any],
+		*args: P.args,
+		**kwargs: P.kwargs,
+	) -> TimerHandleLike:
+		return self._schedule(delay, fn, args, dict(kwargs), untrack=True)
+
+	def call_soon(
+		self, fn: Callable[P, Any], *args: P.args, **kwargs: P.kwargs
+	) -> TimerHandleLike | None:
+		def _schedule():
+			return self._schedule_soon(fn, args, dict(kwargs))
+
+		try:
+			asyncio.get_running_loop()
+			return _schedule()
+		except RuntimeError:
+
+			async def _runner():
+				return _schedule()
+
+			try:
+				return from_thread.run(_runner)
+			except RuntimeError:
+				if not is_pytest():
+					raise
+				return None
+
+	def repeat(
+		self, interval: float, fn: Callable[P, Any], *args: P.args, **kwargs: P.kwargs
+	) -> RepeatHandle:
+		from pulse.reactive import Untrack
+
+		loop = asyncio.get_running_loop()
+		handle = RepeatHandle()
+
+		async def _runner():
+			nonlocal handle
+			try:
+				while not handle.cancelled:
+					# Start counting the next interval AFTER the previous execution completes
+					await asyncio.sleep(interval)
+					if handle.cancelled:
+						break
+					try:
+						with Untrack():
+							result = fn(*args, **kwargs)
+							if asyncio.iscoroutine(result):
+								await result
+					except asyncio.CancelledError:
+						# Propagate to outer handler to finish cleanly
+						raise
+					except Exception as exc:
+						# Surface exceptions via the loop's exception handler and continue
+						loop.call_exception_handler(
+							{
+								"message": "Unhandled exception in repeat() callback",
+								"exception": exc,
+								"context": {"callback": fn},
+							}
+						)
+			except asyncio.CancelledError:
+				# Swallow task cancellation to avoid noisy "exception was never retrieved"
+				pass
+
+		handle.task = self._tasks.create_task(_runner())
+		return handle
+
+	def cancel_all(self) -> None:
+		for handle in list(self._handles):
+			handle.cancel()
+		self._handles.clear()
+
+	def _schedule(
+		self,
+		delay: float,
+		fn: Callable[..., Any],
+		args: tuple[Any, ...],
+		kwargs: dict[str, Any],
+		*,
+		untrack: bool,
+	) -> TimerHandleLike:
+		"""
+		Schedule `fn(*args, **kwargs)` to run after `delay` seconds.
+		Works with sync or async functions. Returns a TimerHandle; call .cancel() to cancel.
+
+		The callback can run without a reactive scope to avoid accidentally capturing
+		reactive dependencies from the calling context. Other context vars (like
+		PulseContext) are preserved normally.
+		"""
+		try:
+			loop = asyncio.get_running_loop()
+		except RuntimeError:
+			try:
+				loop = asyncio.get_event_loop()
+			except RuntimeError as exc:
+				raise RuntimeError("later() requires an event loop") from exc
+
+		tracked_box: list[TimerHandleLike] = []
+		_run = self._prepare_run(loop, tracked_box, fn, args, kwargs, untrack=untrack)
+
+		handle = loop.call_later(delay, _run)
+		tracked = _TrackedTimerHandle(handle, self)
+		tracked_box.append(tracked)
+		self._handles.add(tracked)
+		return tracked
+
+	def _schedule_soon(
+		self,
+		fn: Callable[..., Any],
+		args: tuple[Any, ...],
+		kwargs: dict[str, Any],
+	) -> TimerHandleLike:
+		try:
+			loop = asyncio.get_running_loop()
+		except RuntimeError:
+			try:
+				loop = asyncio.get_event_loop()
+			except RuntimeError as exc:
+				raise RuntimeError("call_soon() requires an event loop") from exc
+
+		tracked_box: list[TimerHandleLike] = []
+		_run = self._prepare_run(loop, tracked_box, fn, args, kwargs, untrack=False)
+
+		handle = loop.call_soon(_run)
+		tracked = _TrackedHandle(handle, self, when=loop.time())
+		tracked_box.append(tracked)
+		self._handles.add(tracked)
+		return tracked
+
+	def _prepare_run(
+		self,
+		loop: asyncio.AbstractEventLoop,
+		tracked_box: list[TimerHandleLike],
+		fn: Callable[..., Any],
+		args: tuple[Any, ...],
+		kwargs: dict[str, Any],
+		*,
+		untrack: bool,
+	) -> Callable[[], None]:
+		def _run():
+			from pulse.reactive import Untrack
+
+			try:
+				if untrack:
+					with Untrack():
+						res = fn(*args, **kwargs)
+				else:
+					res = fn(*args, **kwargs)
+				if asyncio.iscoroutine(res):
+					task = self._tasks.create_task(res)
+
+					def _log_task_exception(t: asyncio.Task[Any]):
+						try:
+							t.result()
+						except asyncio.CancelledError:
+							# Normal cancellation path
+							pass
+						except Exception as exc:
+							loop.call_exception_handler(
+								{
+									"message": "Unhandled exception in later() task",
+									"exception": exc,
+									"context": {"callback": fn},
+								}
+							)
+
+					task.add_done_callback(_log_task_exception)
+			except Exception as exc:
+				# Surface exceptions via the loop's exception handler and continue
+				loop.call_exception_handler(
+					{
+						"message": "Unhandled exception in later() callback",
+						"exception": exc,
+						"context": {"callback": fn},
+					}
+				)
+			finally:
+				self.discard(tracked_box[0] if tracked_box else None)
+
+		return _run
+
+
+class _TrackedTimerHandle:
+	__slots__: tuple[str, ...] = ("_handle", "_registry")
+	_handle: asyncio.TimerHandle
+	_registry: "TimerRegistry"
+
+	def __init__(self, handle: asyncio.TimerHandle, registry: "TimerRegistry") -> None:
+		self._handle = handle
+		self._registry = registry
+
+	def cancel(self) -> None:
+		if not self._handle.cancelled():
+			self._handle.cancel()
+		self._registry.discard(self)
+
+	def cancelled(self) -> bool:
+		return self._handle.cancelled()
+
+	def when(self) -> float:
+		return self._handle.when()
+
+	def __getattr__(self, name: str):
+		return getattr(self._handle, name)
+
+	@override
+	def __hash__(self) -> int:
+		return hash(self._handle)
+
+	@override
+	def __eq__(self, other: object) -> bool:
+		if isinstance(other, _TrackedTimerHandle):
+			return self._handle is other._handle
+		return self._handle is other
+
+
+class _TrackedHandle:
+	__slots__: tuple[str, ...] = ("_handle", "_registry", "_when")
+	_handle: asyncio.Handle
+	_registry: "TimerRegistry"
+	_when: float
+
+	def __init__(
+		self,
+		handle: asyncio.Handle,
+		registry: "TimerRegistry",
+		*,
+		when: float,
+	) -> None:
+		self._handle = handle
+		self._registry = registry
+		self._when = when
+
+	def cancel(self) -> None:
+		if not self._handle.cancelled():
+			self._handle.cancel()
+		self._registry.discard(self)
+
+	def cancelled(self) -> bool:
+		return self._handle.cancelled()
+
+	def when(self) -> float:
+		return self._when
+
+	def __getattr__(self, name: str):
+		return getattr(self._handle, name)
+
+	@override
+	def __hash__(self) -> int:
+		return hash(self._handle)
+
+	@override
+	def __eq__(self, other: object) -> bool:
+		if isinstance(other, _TrackedHandle):
+			return self._handle is other._handle
+		return self._handle is other

{pulse_framework-0.1.64.dist-info → pulse_framework-0.1.65.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pulse-framework
-Version: 0.1.64
+Version: 0.1.65
 Summary: Pulse - Full-stack framework for building real-time React applications in Python
 Requires-Dist: websockets>=12.0
 Requires-Dist: fastapi>=0.128.0