pulse-framework 0.1.64__py3-none-any.whl → 0.1.66a1__py3-none-any.whl

pulse/render_session.py

@@ -1,13 +1,13 @@
 import asyncio
 import logging
+import os
 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 +29,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 +99,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 +130,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
 
@@ -131,6 +138,14 @@ class RouteMount:
 		if self.state != "pending":
 			return
 		action = self.pending_action
+		if os.environ.get("PULSE_DEBUG_RENDER"):
+			logger.info(
+				"[PulseDebug][mount-timeout] render=%s path=%s action=%s state=%s",
+				self.render.id,
+				self.path,
+				action,
+				self.state,
+			)
 		self.pending_action = None
 		if action == "dispose":
 			self.render.dispose_mount(self.path, self)
@@ -138,6 +153,15 @@ class RouteMount:
 		self.to_idle()
 
 	def start_pending(self, timeout: float, *, action: PendingAction = "idle") -> None:
+		if os.environ.get("PULSE_DEBUG_RENDER"):
+			logger.info(
+				"[PulseDebug][mount-pending] render=%s path=%s state=%s action=%s timeout=%s",
+				self.render.id,
+				self.path,
+				self.state,
+				action,
+				timeout,
+			)
 		if self.state == "pending":
 			prev_action = self.pending_action
 			next_action: PendingAction = (
@@ -145,7 +169,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,9 +179,19 @@ 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 os.environ.get("PULSE_DEBUG_RENDER"):
+			logger.info(
+				"[PulseDebug][mount-activate] render=%s path=%s state=%s queued=%s",
+				self.render.id,
+				self.path,
+				self.state,
+				0 if not self.queue else len(self.queue),
+			)
 		if self.state != "pending":
 			return
 		self._cancel_pending_timeout()
@@ -182,6 +218,12 @@ class RouteMount:
 	def to_idle(self) -> None:
 		if self.state != "pending":
 			return
+		if os.environ.get("PULSE_DEBUG_RENDER"):
+			logger.info(
+				"[PulseDebug][mount-idle] render=%s path=%s",
+				self.render.id,
+				self.path,
+			)
 		self.state = "idle"
 		self.queue = None
 		self._cancel_pending_timeout()
@@ -248,6 +290,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 +306,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 +321,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
@@ -303,11 +349,15 @@ class RenderSession:
 
 	def connect(self, send_message: Callable[[ServerMessage], Any]):
 		"""WebSocket connected. Set sender, don't auto-flush (attach does that)."""
+		if os.environ.get("PULSE_DEBUG_RENDER"):
+			logger.info("[PulseDebug][render-connect] render=%s", self.id)
 		self._send_message = send_message
 		self.connected = True
 
 	def disconnect(self):
 		"""WebSocket disconnected. Start queuing briefly before pausing."""
+		if os.environ.get("PULSE_DEBUG_RENDER"):
+			logger.info("[PulseDebug][render-disconnect] render=%s", self.id)
 		self._send_message = None
 		self.connected = False
 
@@ -381,6 +431,13 @@ class RenderSession:
 		- Creates mounts in PENDING state and starts queue
 		"""
 		normalized = [ensure_absolute_path(path) for path in paths]
+		if os.environ.get("PULSE_DEBUG_RENDER"):
+			logger.info(
+				"[PulseDebug][prerender] render=%s paths=%s route_info=%s",
+				self.id,
+				normalized,
+				route_info,
+			)
 
 		results: dict[str, ServerInitMessage | ServerNavigateToMessage] = {}
 
@@ -388,6 +445,15 @@ class RenderSession:
 			route = self.routes.find(path)
 			info = route_info or route.default_route_info()
 			mount = self.route_mounts.get(path)
+			if os.environ.get("PULSE_DEBUG_RENDER"):
+				route_label = repr(route)
+				logger.info(
+					"[PulseDebug][prerender] render=%s path=%s mount_state=%s route=%s",
+					self.id,
+					path,
+					mount.state if mount else None,
+					route_label,
+				)
 
 			if mount is None:
 				mount = RouteMount(self, path, route, info)
@@ -426,13 +492,29 @@ class RenderSession:
 		mount = self.route_mounts.get(path)
 
 		if mount is None or mount.state == "idle":
+			if os.environ.get("PULSE_DEBUG_RENDER"):
+				logger.info(
+					"[PulseDebug][attach] render=%s path=%s mount_state=%s mounts=%s route_info=%s",
+					self.id,
+					path,
+					mount.state if mount else None,
+					{key: value.state for key, value in self.route_mounts.items()},
+					route_info,
+				)
 			# Initial render must come from prerender
+			print(f"[DEBUG] Missing or idle route '{path}', reloading")
 			self.send({"type": "reload"})
 			return
 
 		# Update route info for active and pending mounts
 		mount.update_route(route_info)
 		if mount.state == "pending" and self._send_message:
+			if os.environ.get("PULSE_DEBUG_RENDER"):
+				logger.info(
+					"[PulseDebug][attach] render=%s path=%s activating=true",
+					self.id,
+					path,
+				)
 			mount.activate(self._send_message)
 
 	def update_route(self, path: str, route_info: RouteInfo):
@@ -448,6 +530,13 @@ class RenderSession:
 		current = self.route_mounts.get(path)
 		if current is not mount:
 			return
+		if os.environ.get("PULSE_DEBUG_RENDER"):
+			logger.info(
+				"[PulseDebug][mount-dispose] render=%s path=%s state=%s",
+				self.id,
+				path,
+				mount.state,
+			)
 		try:
 			self.route_mounts.pop(path, None)
 			mount.dispose()
@@ -546,9 +635,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 +679,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 +712,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 +751,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 +869,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