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

pulse/queries/query.py

@@ -18,9 +18,8 @@ from pulse.context import PulseContext
 from pulse.helpers import (
 	MISSING,
 	Disposable,
+	Missing,
 	call_flexible,
-	is_pytest,
-	later,
 	maybe_await,
 )
 from pulse.queries.common import (
@@ -35,6 +34,7 @@ from pulse.queries.common import (
 )
 from pulse.queries.effect import AsyncQueryEffect
 from pulse.reactive import Computed, Effect, Signal, Untrack
+from pulse.scheduling import TimerHandleLike, create_task, is_pytest, later
 from pulse.state import InitializableProperty, State
 
 if TYPE_CHECKING:
@@ -64,7 +64,7 @@ class QueryConfig(Generic[T]):
 
 	retries: int
 	retry_delay: float
-	initial_data: T | Callable[[], T] | None
+	initial_data: T | Callable[[], T] | Missing | None
 	initial_data_updated_at: float | dt.datetime | None
 	gc_time: float
 	on_dispose: Callable[[Any], None] | None
@@ -90,7 +90,7 @@ class QueryState(Generic[T]):
 	cfg: QueryConfig[T]
 
 	# Reactive signals for query state
-	data: Signal[T | None]
+	data: Signal[T | None | Missing]
 	error: Signal[Exception | None]
 	last_updated: Signal[float]
 	status: Signal[QueryStatus]
@@ -103,7 +103,7 @@ class QueryState(Generic[T]):
 		name: str,
 		retries: int = 3,
 		retry_delay: float = RETRY_DELAY_DEFAULT,
-		initial_data: T | None = MISSING,
+		initial_data: T | Missing | None = MISSING,
 		initial_data_updated_at: float | dt.datetime | None = None,
 		gc_time: float = 300.0,
 		on_dispose: Callable[[Any], None] | None = None,
@@ -119,7 +119,7 @@ class QueryState(Generic[T]):
 
 		# Initialize reactive signals
 		self.data = Signal(
-			None if initial_data is MISSING else initial_data,
+			MISSING if initial_data is MISSING else initial_data,
 			name=f"query.data({name})",
 		)
 		self.error = Signal(None, name=f"query.error({name})")
@@ -147,7 +147,8 @@ class QueryState(Generic[T]):
 	):
 		"""Set data manually, accepting a value or updater function."""
 		current = self.data.read()
-		new_value = cast(T, data(current) if callable(data) else data)
+		current_value = cast(T | None, None if current is MISSING else current)
+		new_value = cast(T, data(current_value) if callable(data) else data)
 		self.set_success(new_value, manual=True)
 		if updated_at is not None:
 			self.set_updated_at(updated_at)
@@ -225,7 +226,7 @@ async def run_fetch_with_retries(
 		on_success: Optional callback on success
 		on_error: Optional callback on error
 		untrack: If True, wrap fetch_fn in Untrack() to prevent dependency tracking.
-		         Use for keyed queries where fetch is triggered via asyncio.create_task.
+		         Use for keyed queries where fetch is triggered via create_task().
 	"""
 	state.reset_retries()
 
@@ -267,14 +268,17 @@ class KeyedQuery(Generic[T], Disposable):
 	observers: "list[KeyedQueryResult[T]]"
 	_task: asyncio.Task[None] | None
 	_task_initiator: "KeyedQueryResult[T] | None"
-	_gc_handle: asyncio.TimerHandle | None
+	_gc_handle: TimerHandleLike | None
+	_interval_effect: Effect | None
+	_interval: float | None
+	_interval_observer: "KeyedQueryResult[T] | None"
 
 	def __init__(
 		self,
 		key: QueryKey,
 		retries: int = 3,
 		retry_delay: float = RETRY_DELAY_DEFAULT,
-		initial_data: T | None = MISSING,
+		initial_data: T | Missing | None = MISSING,
 		initial_data_updated_at: float | dt.datetime | None = None,
 		gc_time: float = 300.0,
 		on_dispose: Callable[[Any], None] | None = None,
@@ -293,10 +297,13 @@ class KeyedQuery(Generic[T], Disposable):
 		self._task = None
 		self._task_initiator = None
 		self._gc_handle = None
+		self._interval_effect = None
+		self._interval = None
+		self._interval_observer = None
 
 	# --- Delegate signal access to state ---
 	@property
-	def data(self) -> Signal[T | None]:
+	def data(self) -> Signal[T | None | Missing]:
 		return self.state.data
 
 	@property
@@ -377,7 +384,7 @@ class KeyedQuery(Generic[T], Disposable):
 			fetch_fn,
 			on_success=on_success,
 			on_error=on_error,
-			untrack=True,  # Keyed queries use asyncio.create_task, need to untrack
+			untrack=True,  # Keyed queries use create_task(), need to untrack
 		)
 
 	def run_fetch(
@@ -401,7 +408,7 @@ class KeyedQuery(Generic[T], Disposable):
 		self.state.is_fetching.write(True)
 		# Capture current observers at fetch start
 		observers = list(self.observers)
-		self._task = asyncio.create_task(self._run_fetch(fetch_fn, observers))
+		self._task = create_task(self._run_fetch(fetch_fn, observers))
 		self._task_initiator = initiator
 		return self._task
 
@@ -421,7 +428,10 @@ class KeyedQuery(Generic[T], Disposable):
 		# Return result based on current state
 		if self.state.status() == "error":
 			return ActionError(cast(Exception, self.state.error.read()))
-		return ActionSuccess(cast(T, self.state.data.read()))
+		data = self.state.data.read()
+		if data is MISSING:
+			return ActionSuccess(cast(T, None))
+		return ActionSuccess(cast(T, data))
 
 	def cancel(self) -> None:
 		"""Cancel the current fetch if running."""
@@ -438,6 +448,66 @@ class KeyedQuery(Generic[T], Disposable):
 			)
 		return self.observers[0]._fetch_fn  # pyright: ignore[reportPrivateUsage]
 
+	@property
+	def has_interval(self) -> bool:
+		return self._interval is not None
+
+	def _select_interval_observer(
+		self,
+	) -> tuple[float | None, "KeyedQueryResult[T] | None"]:
+		min_interval: float | None = None
+		selected: "KeyedQueryResult[T] | None" = None
+
+		for obs in reversed(self.observers):
+			interval = obs._refetch_interval  # pyright: ignore[reportPrivateUsage]
+			if interval is None:
+				continue
+			if not obs._enabled.value:  # pyright: ignore[reportPrivateUsage]
+				continue
+			if min_interval is None or interval < min_interval:
+				min_interval = interval
+				selected = obs
+
+		return min_interval, selected
+
+	def _create_interval_effect(self, interval: float) -> Effect:
+		def interval_fn():
+			observer = self._interval_observer
+			if observer is None:
+				return
+			if not self.is_scheduled and len(self.observers) > 0:
+				self.run_fetch(
+					observer._fetch_fn,  # pyright: ignore[reportPrivateUsage]
+					cancel_previous=False,
+					initiator=observer,
+				)
+
+		return Effect(
+			interval_fn,
+			name=f"query_interval({self.key})",
+			interval=interval,
+			immediate=True,
+		)
+
+	def _update_interval(self) -> None:
+		new_interval, new_observer = self._select_interval_observer()
+		interval_changed = new_interval != self._interval
+
+		self._interval = new_interval
+		self._interval_observer = new_observer
+
+		if not interval_changed:
+			if self._interval_effect is None and new_interval is not None:
+				self._interval_effect = self._create_interval_effect(new_interval)
+			return
+
+		if self._interval_effect is not None:
+			self._interval_effect.dispose()
+			self._interval_effect = None
+
+		if new_interval is not None:
+			self._interval_effect = self._create_interval_effect(new_interval)
+
 	async def refetch(self, cancel_refetch: bool = True) -> ActionResult[T]:
 		"""
 		Reruns the query and returns the result.
@@ -468,11 +538,13 @@ class KeyedQuery(Generic[T], Disposable):
 		self.cancel_gc()
 		if observer._gc_time > 0:  # pyright: ignore[reportPrivateUsage]
 			self.cfg.gc_time = max(self.cfg.gc_time, observer._gc_time)  # pyright: ignore[reportPrivateUsage]
+		self._update_interval()
 
 	def unobserve(self, observer: "KeyedQueryResult[T]"):
 		"""Unregister an observer. Schedules GC if no observers remain."""
 		if observer in self.observers:
 			self.observers.remove(observer)
+		self._update_interval()
 
 		# If the departing observer initiated the ongoing fetch, cancel it
 		if self._task_initiator is observer and self._task and not self._task.done():
@@ -505,6 +577,9 @@ class KeyedQuery(Generic[T], Disposable):
 	def dispose(self):
 		"""Clean up the query, cancelling any in-flight fetch."""
 		self.cancel()
+		if self._interval_effect is not None:
+			self._interval_effect.dispose()
+			self._interval_effect = None
 		if self.cfg.on_dispose:
 			self.cfg.on_dispose(self)
 
@@ -528,7 +603,7 @@ class UnkeyedQueryResult(Generic[T], Disposable):
 	_keep_previous_data: bool
 	_enabled: Signal[bool]
 	_interval_effect: Effect | None
-	_data_computed: Computed[T | None]
+	_data_computed: Computed[T | None | Missing]
 
 	def __init__(
 		self,
@@ -537,7 +612,7 @@ class UnkeyedQueryResult(Generic[T], Disposable):
 		on_error: Callable[[Exception], Awaitable[None] | None] | None = None,
 		retries: int = 3,
 		retry_delay: float = RETRY_DELAY_DEFAULT,
-		initial_data: T | None = MISSING,
+		initial_data: T | Missing | None = MISSING,
 		initial_data_updated_at: float | dt.datetime | None = None,
 		gc_time: float = 300.0,
 		stale_time: float = 0.0,
@@ -559,7 +634,12 @@ class UnkeyedQueryResult(Generic[T], Disposable):
 		self._on_success = on_success
 		self._on_error = on_error
 		self._stale_time = stale_time
-		self._refetch_interval = refetch_interval
+		interval = (
+			refetch_interval
+			if refetch_interval is not None and refetch_interval > 0
+			else None
+		)
+		self._refetch_interval = interval
 		self._keep_previous_data = keep_previous_data
 		self._enabled = Signal(enabled, name="query.enabled(unkeyed)")
 		self._interval_effect = None
@@ -576,17 +656,20 @@ class UnkeyedQueryResult(Generic[T], Disposable):
 
 		# Computed for keep_previous_data logic
 		self._data_computed = Computed(
-			self._data_computed_fn, name="query_data(unkeyed)"
+			self._data_computed_fn,
+			name="query_data(unkeyed)",
+			initial_value=MISSING,
 		)
 
 		# Schedule initial fetch if stale (untracked to avoid reactive loop)
 		with Untrack():
-			if enabled and fetch_on_mount and self.is_stale():
+			# Skip if refetch_interval is active - interval effect handles initial fetch
+			if enabled and fetch_on_mount and interval is None and self.is_stale():
 				self.schedule()
 
 		# Set up interval effect if interval is specified
-		if refetch_interval is not None and refetch_interval > 0:
-			self._setup_interval_effect(refetch_interval)
+		if interval is not None:
+			self._setup_interval_effect(interval)
 
 	def _setup_interval_effect(self, interval: float):
 		"""Create an effect that invalidates the query at the specified interval."""
@@ -602,12 +685,12 @@ class UnkeyedQueryResult(Generic[T], Disposable):
 			immediate=True,
 		)
 
-	def _data_computed_fn(self, prev: T | None) -> T | None:
-		if self._keep_previous_data and self.state.status() != "success":
+	def _data_computed_fn(self, prev: T | None | Missing) -> T | None | Missing:
+		if self._keep_previous_data and self.state.status() == "loading":
 			return prev
 		raw = self.state.data()
-		if raw is None:
-			return None
+		if raw is MISSING:
+			return MISSING
 		return raw
 
 	# --- Status properties ---
@@ -637,7 +720,10 @@ class UnkeyedQueryResult(Generic[T], Disposable):
 
 	@property
 	def data(self) -> T | None:
-		return self._data_computed()
+		value = self._data_computed()
+		if value is MISSING:
+			return None
+		return cast(T | None, value)
 
 	# --- State methods ---
 	def set_data(self, data: T | Callable[[T | None], T]):
@@ -699,14 +785,20 @@ class UnkeyedQueryResult(Generic[T], Disposable):
 		return await self.wait()
 
 	async def wait(self) -> ActionResult[T]:
-		"""Wait for the current query to complete."""
-		# If loading and no task, schedule a fetch
-		if self.state.status() == "loading" and not self.state.is_fetching():
-			self.schedule()
+		"""Wait for the current in-flight fetch to complete."""
 		await self._effect.wait()
 		if self.state.status() == "error":
 			return ActionError(cast(Exception, self.state.error.read()))
-		return ActionSuccess(cast(T, self.state.data.read()))
+		data = self.state.data.read()
+		if data is MISSING:
+			return ActionSuccess(cast(T, None))
+		return ActionSuccess(cast(T, data))
+
+	async def ensure(self) -> ActionResult[T]:
+		"""Ensure an initial fetch has started, then wait for completion."""
+		if self.state.status() == "loading" and not self.state.is_fetching():
+			self.schedule()
+		return await self.wait()
 
 	def invalidate(self):
 		"""Mark the query as stale and refetch through the effect."""
@@ -740,8 +832,7 @@ class KeyedQueryResult(Generic[T], Disposable):
 	_on_success: Callable[[T], Awaitable[None] | None] | None
 	_on_error: Callable[[Exception], Awaitable[None] | None] | None
 	_observe_effect: Effect
-	_interval_effect: Effect | None
-	_data_computed: Computed[T | None]
+	_data_computed: Computed[T | None | Missing]
 	_enabled: Signal[bool]
 	_fetch_on_mount: bool
 
@@ -762,12 +853,16 @@ class KeyedQueryResult(Generic[T], Disposable):
 		self._fetch_fn = fetch_fn
 		self._stale_time = stale_time
 		self._gc_time = gc_time
-		self._refetch_interval = refetch_interval
+		interval = (
+			refetch_interval
+			if refetch_interval is not None and refetch_interval > 0
+			else None
+		)
+		self._refetch_interval = interval
 		self._keep_previous_data = keep_previous_data
 		self._on_success = on_success
 		self._on_error = on_error
 		self._enabled = Signal(enabled, name=f"query.enabled({query().key})")
-		self._interval_effect = None
 
 		def observe_effect():
 			q = self._query()
@@ -776,9 +871,11 @@ class KeyedQueryResult(Generic[T], Disposable):
 			with Untrack():
 				q.observe(self)
 
-				# If stale or loading, schedule refetch (only when enabled)
-				if enabled and fetch_on_mount and self.is_stale():
-					self.invalidate()
+				# Skip if query interval is active - interval effect handles initial fetch
+				if enabled and fetch_on_mount and not q.has_interval:
+					# If stale, schedule refetch (only when enabled)
+					if not q.is_fetching() and self.is_stale():
+						self.invalidate()
 
 			# Return cleanup function that captures the query (old query on key change)
 			def cleanup():
@@ -792,26 +889,9 @@ class KeyedQueryResult(Generic[T], Disposable):
 			immediate=True,
 		)
 		self._data_computed = Computed(
-			self._data_computed_fn, name=f"query_data({self._query().key})"
-		)
-
-		# Set up interval effect if interval is specified
-		if refetch_interval is not None and refetch_interval > 0:
-			self._setup_interval_effect(refetch_interval)
-
-	def _setup_interval_effect(self, interval: float):
-		"""Create an effect that invalidates the query at the specified interval."""
-
-		def interval_fn():
-			# Read enabled to make this effect reactive to enabled changes
-			if self._enabled():
-				self.invalidate()
-
-		self._interval_effect = Effect(
-			interval_fn,
-			name=f"query_interval({self._query().key})",
-			interval=interval,
-			immediate=True,
+			self._data_computed_fn,
+			name=f"query_data({self._query().key})",
+			initial_value=MISSING,
 		)
 
 	@property
@@ -842,18 +922,18 @@ class KeyedQueryResult(Generic[T], Disposable):
 	def error(self) -> Exception | None:
 		return self._query().error.read()
 
-	def _data_computed_fn(self, prev: T | None) -> T | None:
+	def _data_computed_fn(self, prev: T | None | Missing) -> T | None | Missing:
 		query = self._query()
-		if self._keep_previous_data and query.status() != "success":
+		if self._keep_previous_data and query.status() == "loading":
 			return prev
-		raw = query.data()
-		if raw is None:
-			return None
-		return raw
+		return query.data()
 
 	@property
 	def data(self) -> T | None:
-		return self._data_computed()
+		value = self._data_computed()
+		if value is MISSING:
+			return None
+		return cast(T | None, value)
 
 	def is_stale(self) -> bool:
 		"""Check if the query data is stale based on stale_time."""
@@ -874,9 +954,12 @@ class KeyedQueryResult(Generic[T], Disposable):
 		return await self.wait()
 
 	async def wait(self) -> ActionResult[T]:
-		"""Wait for the current query to complete."""
+		"""Wait for the current in-flight fetch to complete."""
+		return await self._query().wait()
+
+	async def ensure(self) -> ActionResult[T]:
+		"""Ensure an initial fetch has started, then wait for completion."""
 		query = self._query()
-		# If loading and no task, start a fetch with this observer's fetch function
 		if query.status() == "loading" and not query.is_fetching():
 			query.run_fetch(self._fetch_fn, initiator=self)
 		return await query.wait()
@@ -910,16 +993,16 @@ class KeyedQueryResult(Generic[T], Disposable):
 	def enable(self):
 		"""Enable the query."""
 		self._enabled.write(True)
+		self._query()._update_interval()  # pyright: ignore[reportPrivateUsage]
 
 	def disable(self):
 		"""Disable the query, preventing it from fetching."""
 		self._enabled.write(False)
+		self._query()._update_interval()  # pyright: ignore[reportPrivateUsage]
 
 	@override
 	def dispose(self):
 		"""Clean up the result and its observe effect."""
-		if self._interval_effect is not None and not self._interval_effect.__disposed__:
-			self._interval_effect.dispose()
 		if not self._observe_effect.__disposed__:
 			self._observe_effect.dispose()
 
@@ -970,7 +1053,7 @@ class QueryProperty(Generic[T, TState], InitializableProperty):
 	_retry_delay: float
 	_initial_data_updated_at: float | dt.datetime | None
 	_enabled: bool
-	_initial_data: T | Callable[[TState], T] | None
+	_initial_data: T | Callable[[TState], T] | Missing | None
 	_key: QueryKey | Callable[[TState], QueryKey] | None
 	# Not using OnSuccessFn and OnErrorFn since unions of callables are not well
 	# supported in the type system. We just need to be careful to use
@@ -1007,7 +1090,7 @@ class QueryProperty(Generic[T, TState], InitializableProperty):
 		self._retries = retries
 		self._retry_delay = retry_delay
 		self._initial_data_updated_at = initial_data_updated_at
-		self._initial_data = MISSING  # pyright: ignore[reportAttributeAccessIssue]
+		self._initial_data = MISSING
 		self._enabled = enabled
 		self._fetch_on_mount = fetch_on_mount
 		self._priv_result = f"__query_{name}"
@@ -1062,13 +1145,13 @@ class QueryProperty(Generic[T, TState], InitializableProperty):
 
 		# Bind methods to this instance
 		fetch_fn = bind_state(state, self._fetch_fn)
-		initial_data = cast(
-			T | None,
-			(
-				call_flexible(self._initial_data, state)
-				if callable(self._initial_data)
-				else self._initial_data
-			),
+		raw_initial = (
+			call_flexible(self._initial_data, state)
+			if callable(self._initial_data)
+			else self._initial_data
+		)
+		initial_data = (
+			MISSING if raw_initial is MISSING else cast(T | None, raw_initial)
 		)
 
 		if self._key is None:
@@ -1096,7 +1179,7 @@ class QueryProperty(Generic[T, TState], InitializableProperty):
 		self,
 		state: TState,
 		fetch_fn: Callable[[], Awaitable[T]],
-		initial_data: T | None,
+		initial_data: T | Missing | None,
 		initial_data_updated_at: float | dt.datetime | None,
 	) -> KeyedQueryResult[T]:
 		"""Create or get a keyed query from the session store."""
@@ -1151,7 +1234,7 @@ class QueryProperty(Generic[T, TState], InitializableProperty):
 	def _create_unkeyed(
 		self,
 		fetch_fn: Callable[[], Awaitable[T]],
-		initial_data: T | None,
+		initial_data: T | Missing | None,
 		initial_data_updated_at: float | dt.datetime | None,
 		state: TState,
 	) -> UnkeyedQueryResult[T]:
@@ -1244,7 +1327,7 @@ def query(
 		stale_time: Seconds before data is considered stale (default 0.0).
 		gc_time: Seconds to keep unused query in cache (default 300.0, None to disable).
 		refetch_interval: Auto-refetch interval in seconds (default None, disabled).
-		keep_previous_data: Keep previous data while refetching (default False).
+		keep_previous_data: Keep previous data while loading (default False).
 		retries: Number of retry attempts on failure (default 3).
 		retry_delay: Delay between retries in seconds (default 2.0).
 		initial_data_updated_at: Timestamp for initial data staleness calculation.

pulse/queries/store.py

@@ -2,7 +2,7 @@ import datetime as dt
 from collections.abc import Callable
 from typing import Any, TypeVar, cast
 
-from pulse.helpers import MISSING
+from pulse.helpers import MISSING, Missing
 from pulse.queries.common import QueryKey
 from pulse.queries.infinite_query import InfiniteQuery, Page
 from pulse.queries.query import RETRY_DELAY_DEFAULT, KeyedQuery
@@ -29,7 +29,7 @@ class QueryStore:
 	def ensure(
 		self,
 		key: QueryKey,
-		initial_data: T | None = MISSING,
+		initial_data: T | Missing | None = MISSING,
 		initial_data_updated_at: float | dt.datetime | None = None,
 		gc_time: float = 300.0,
 		retries: int = 3,
@@ -87,6 +87,7 @@ class QueryStore:
 		get_previous_page_param: Callable[[list[Page[Any, Any]]], Any | None]
 		| None = None,
 		max_pages: int = 0,
+		initial_data: list[Page[Any, Any]] | Missing | None = MISSING,
 		initial_data_updated_at: float | dt.datetime | None = None,
 		gc_time: float = 300.0,
 		retries: int = 3,
@@ -110,6 +111,7 @@ class QueryStore:
 			get_next_page_param=get_next_page_param,
 			get_previous_page_param=get_previous_page_param,
 			max_pages=max_pages,
+			initial_data=initial_data,
 			initial_data_updated_at=initial_data_updated_at,
 			gc_time=gc_time,
 			retries=retries,
@@ -118,3 +120,9 @@ class QueryStore:
 		)
 		self._entries[key] = entry
 		return entry
+
+	def dispose_all(self) -> None:
+		"""Dispose all queries and clear the store."""
+		for entry in list(self._entries.values()):
+			entry.dispose()
+		self._entries.clear()

pulse/reactive.py

@@ -15,11 +15,14 @@ from typing import (
 
 from pulse.helpers import (
 	Disposable,
-	create_task,
 	maybe_await,
-	schedule_on_loop,
 	values_equal,
 )
+from pulse.scheduling import (
+	TimerHandleLike,
+	call_soon,
+	create_task,
+)
 
 T = TypeVar("T")
 T_co = TypeVar("T_co", covariant=True)
@@ -151,6 +154,7 @@ class Computed(Generic[T_co]):
 		fn: Function computing the value. May optionally accept prev_value
 			as first positional argument for incremental computation.
 		name: Debug name for the computed.
+		initial_value: Seed value used as prev_value on first compute.
 
 	Attributes:
 		value: Cached computed value.
@@ -171,13 +175,20 @@ class Computed(Generic[T_co]):
 
 	fn: Callable[..., T_co]
 	name: str | None
+	value: Any
 	dirty: bool
 	on_stack: bool
 	accepts_prev_value: bool
 
-	def __init__(self, fn: Callable[..., T_co], name: str | None = None):
+	def __init__(
+		self,
+		fn: Callable[..., T_co],
+		name: str | None = None,
+		*,
+		initial_value: Any = None,
+	):
 		self.fn = fn
-		self.value: T_co = None  # pyright: ignore[reportAttributeAccessIssue]
+		self.value = initial_value
 		self.name = name
 		self.dirty = False
 		self.on_stack = False
@@ -384,7 +395,7 @@ class Effect(Disposable):
 	immediate: bool
 	_lazy: bool
 	_interval: float | None
-	_interval_handle: asyncio.TimerHandle | None
+	_interval_handle: TimerHandleLike | None
 	update_deps: bool
 	batch: "Batch | None"
 	paused: bool
@@ -461,7 +472,7 @@ class Effect(Disposable):
 	def _schedule_interval(self):
 		"""Schedule the next interval run if interval is set."""
 		if self._interval is not None and self._interval > 0:
-			from pulse.helpers import later
+			from pulse.scheduling import later
 
 			self._interval_handle = later(self._interval, self._on_interval)
 
@@ -995,7 +1006,7 @@ class GlobalBatch(Batch):
 	@override
 	def register_effect(self, effect: Effect):
 		if not self.is_scheduled:
-			schedule_on_loop(self.flush)
+			call_soon(self.flush)
 			self.is_scheduled = True
 		return super().register_effect(effect)