pulse-framework 0.1.42__py3-none-any.whl → 0.1.43__py3-none-any.whl

pulse/queries/store.py

@@ -1,7 +1,10 @@
+import datetime as dt
 from collections.abc import Awaitable, Callable
-from typing import Any, TypeVar
+from typing import Any, TypeVar, cast
 
-from pulse.queries.query import RETRY_DELAY_DEFAULT, Query, QueryKey
+from pulse.queries.common import QueryKey
+from pulse.queries.infinite_query import InfiniteQuery, Page
+from pulse.queries.query import RETRY_DELAY_DEFAULT, Query
 
 T = TypeVar("T")
 
@@ -12,9 +15,14 @@ class QueryStore:
 	"""
 
 	def __init__(self):
-		self._entries: dict[QueryKey, Query[Any]] = {}
+		self._entries: dict[QueryKey, Query[Any] | InfiniteQuery[Any, Any]] = {}
 
-	def get(self, key: QueryKey) -> Query[Any] | None:
+	def items(self):
+		"""Iterate over all (key, query) pairs in the store."""
+		return self._entries.items()
+
+	def get_any(self, key: QueryKey) -> Query[Any] | InfiniteQuery[Any, Any] | None:
+		"""Get any query (regular or infinite) by key, or None if not found."""
 		return self._entries.get(key)
 
 	def ensure(
@@ -22,13 +30,19 @@ class QueryStore:
 		key: QueryKey,
 		fetch_fn: Callable[[], Awaitable[T]],
 		initial_data: T | None = None,
+		initial_data_updated_at: float | dt.datetime | None = None,
 		gc_time: float = 300.0,
 		retries: int = 3,
 		retry_delay: float = RETRY_DELAY_DEFAULT,
 	) -> Query[T]:
 		# Return existing entry if present
-		if key in self._entries:
-			return self._entries[key]
+		existing = self._entries.get(key)
+		if existing:
+			if isinstance(existing, InfiniteQuery):
+				raise TypeError(
+					"Query key is already used for an infinite query; cannot reuse for regular query"
+				)
+			return cast(Query[T], existing)
 
 		def _on_dispose(e: Query[Any]) -> None:
 			if e.key in self._entries and self._entries[e.key] is e:
@@ -38,6 +52,7 @@ class QueryStore:
 			key,
 			fetch_fn,
 			initial_data=initial_data,
+			initial_data_updated_at=initial_data_updated_at,
 			gc_time=gc_time,
 			retries=retries,
 			retry_delay=retry_delay,
@@ -46,15 +61,63 @@ class QueryStore:
 		self._entries[key] = entry
 		return entry
 
-	def remove(self, key: QueryKey):
-		entry = self._entries.get(key)
-		if entry:
-			entry.dispose()
-
-	def get_queries(
-		self, predicate: Callable[[Query[Any]], bool] | None = None
-	) -> list[Query[Any]]:
-		"""Get all queries matching the predicate."""
-		if predicate is None:
-			return list(self._entries.values())
-		return [e for e in self._entries.values() if predicate(e)]
+	def get(self, key: QueryKey) -> Query[Any] | None:
+		"""
+		Get an existing regular query by key, or None if not found.
+		"""
+		existing = self._entries.get(key)
+		if existing and isinstance(existing, InfiniteQuery):
+			return None
+		return existing
+
+	def get_infinite(self, key: QueryKey) -> InfiniteQuery[Any, Any] | None:
+		"""
+		Get an existing infinite query by key, or None if not found.
+		"""
+		existing = self._entries.get(key)
+		if existing and isinstance(existing, InfiniteQuery):
+			return existing
+		return None
+
+	def ensure_infinite(
+		self,
+		key: QueryKey,
+		query_fn: Callable[[Any], Awaitable[Any]],
+		*,
+		initial_page_param: Any,
+		get_next_page_param: Callable[[list[Page[Any, Any]]], Any | None],
+		get_previous_page_param: Callable[[list[Page[Any, Any]]], Any | None]
+		| None = None,
+		max_pages: int = 0,
+		initial_data_updated_at: float | dt.datetime | None = None,
+		gc_time: float = 300.0,
+		retries: int = 3,
+		retry_delay: float = RETRY_DELAY_DEFAULT,
+	) -> InfiniteQuery[Any, Any]:
+		existing = self._entries.get(key)
+		if existing:
+			if not isinstance(existing, InfiniteQuery):
+				raise TypeError(
+					"Query key is already used for a regular query; cannot reuse for infinite query"
+				)
+			return existing
+
+		def _on_dispose(e: InfiniteQuery[Any, Any]) -> None:
+			if e.key in self._entries and self._entries[e.key] is e:
+				del self._entries[e.key]
+
+		entry = InfiniteQuery(
+			key,
+			query_fn,
+			initial_page_param=initial_page_param,
+			get_next_page_param=get_next_page_param,
+			get_previous_page_param=get_previous_page_param,
+			max_pages=max_pages,
+			initial_data_updated_at=initial_data_updated_at,
+			gc_time=gc_time,
+			retries=retries,
+			retry_delay=retry_delay,
+			on_dispose=_on_dispose,
+		)
+		self._entries[key] = entry
+		return entry

pulse/reactive.py

@@ -21,6 +21,7 @@ from pulse.helpers import (
 )
 
 T = TypeVar("T")
+T_co = TypeVar("T_co", covariant=True)
 P = ParamSpec("P")
 
 
@@ -95,16 +96,16 @@ class Signal(Generic[T]):
 			obs.push_change()
 
 
-class Computed(Generic[T]):
-	fn: Callable[..., T]
+class Computed(Generic[T_co]):
+	fn: Callable[..., T_co]
 	name: str | None
 	dirty: bool
 	on_stack: bool
 	accepts_prev_value: bool
 
-	def __init__(self, fn: Callable[..., T], name: str | None = None):
+	def __init__(self, fn: Callable[..., T_co], name: str | None = None):
 		self.fn = fn
-		self.value: T = None  # pyright: ignore[reportAttributeAccessIssue]
+		self.value: T_co = None  # pyright: ignore[reportAttributeAccessIssue]
 		self.name = name
 		self.dirty = False
 		self.on_stack = False
@@ -126,7 +127,7 @@ class Computed(Generic[T]):
 			for p in params
 		)
 
-	def read(self) -> T:
+	def read(self) -> T_co:
 		if self.on_stack:
 			raise RuntimeError("Circular dependency detected")
 
@@ -139,10 +140,10 @@ class Computed(Generic[T]):
 			rc.scope.register_dep(self)
 		return self.value
 
-	def __call__(self) -> T:
+	def __call__(self) -> T_co:
 		return self.read()
 
-	def unwrap(self) -> T:
+	def unwrap(self) -> T_co:
 		"""Return the current value while registering subscriptions."""
 		return self.read()
 
@@ -269,6 +270,8 @@ class Effect(Disposable):
 	last_run: int
 	immediate: bool
 	_lazy: bool
+	_interval: float | None
+	_interval_handle: asyncio.TimerHandle | None
 	explicit_deps: bool
 	batch: "Batch | None"
 
@@ -280,6 +283,7 @@ class Effect(Disposable):
 		lazy: bool = False,
 		on_error: Callable[[Exception], None] | None = None,
 		deps: list[Signal[Any] | Computed[Any]] | None = None,
+		interval: float | None = None,
 	):
 		self.fn = fn  # type: ignore[assignment]
 		self.name = name
@@ -295,6 +299,8 @@ class Effect(Disposable):
 		self.explicit_deps = deps is not None
 		self.immediate = immediate
 		self._lazy = lazy
+		self._interval = interval
+		self._interval_handle = None
 
 		if immediate and lazy:
 			raise ValueError("An effect cannot be boht immediate and lazy")
@@ -322,7 +328,7 @@ class Effect(Disposable):
 
 	@override
 	def dispose(self):
-		self.unschedule()
+		self.cancel(cancel_interval=True)
 		for child in self.children.copy():
 			child.dispose()
 		if self.cleanup_fn:
@@ -332,6 +338,26 @@ class Effect(Disposable):
 		if self.parent:
 			self.parent.children.remove(self)
 
+	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
+
+			self._interval_handle = later(self._interval, self._on_interval)
+
+	def _on_interval(self):
+		"""Called when the interval timer fires."""
+		if self._interval is not None:
+			# Run directly instead of scheduling - interval runs are unconditional
+			self.run()
+			self._schedule_interval()
+
+	def _cancel_interval(self):
+		"""Cancel the interval timer."""
+		if self._interval_handle is not None:
+			self._interval_handle.cancel()
+			self._interval_handle = None
+
 	def schedule(self):
 		# Immediate effects run right away when scheduled and do not enter a batch
 		if self.immediate:
@@ -342,12 +368,26 @@ class Effect(Disposable):
 		batch.register_effect(self)
 		self.batch = batch
 
-	def unschedule(self):
+	def cancel(self, cancel_interval: bool = True):
+		"""
+		Cancel the effect. For sync effects, removes from batch.
+		For async effects (override), also cancels the running task.
+
+		Args:
+			cancel_interval: If True (default), also cancels the interval timer.
+		"""
 		if self.batch is not None:
 			self.batch.effects.remove(self)
 			self.batch = None
+		if cancel_interval:
+			self._cancel_interval()
 
 	def push_change(self):
+		# Short-circuit if already scheduled in a batch.
+		# This avoids redundant schedule() calls and O(n) list checks
+		# when the same effect is reached through multiple dependency paths.
+		if self.batch is not None:
+			return
 		self.schedule()
 
 	def should_run(self):
@@ -427,6 +467,7 @@ class Effect(Disposable):
 			"lazy": self._lazy,
 			"on_error": self.on_error,
 			"deps": deps,
+			"interval": self._interval,
 		}
 
 	def __copy__(self):
@@ -472,12 +513,16 @@ class Effect(Disposable):
 			self.runs += 1
 			self.last_run = execution_epoch
 		self._apply_scope_results(scope, captured_last_changes)
+		# Start/restart interval if set and not currently scheduled
+		if self._interval is not None and self._interval_handle is None:
+			self._schedule_interval()
 
 
 class AsyncEffect(Effect):
 	fn: AsyncEffectFn  # pyright: ignore[reportIncompatibleMethodOverride]
 	batch: None  # pyright: ignore[reportIncompatibleVariableOverride]
 	_task: asyncio.Task[None] | None
+	_task_started: bool
 
 	def __init__(
 		self,
@@ -486,9 +531,11 @@ class AsyncEffect(Effect):
 		lazy: bool = False,
 		on_error: Callable[[Exception], None] | None = None,
 		deps: list[Signal[Any] | Computed[Any]] | None = None,
+		interval: float | None = None,
 	):
 		# Track an async task when running async effects
 		self._task = None
+		self._task_started = False
 		super().__init__(
 			fn=fn,  # pyright: ignore[reportArgumentType]
 			name=name,
@@ -496,8 +543,19 @@ class AsyncEffect(Effect):
 			lazy=lazy,
 			on_error=on_error,
 			deps=deps,
+			interval=interval,
 		)
 
+	@override
+	def push_change(self):
+		# Short-circuit if task exists but hasn't started executing yet.
+		# This avoids cancelling and recreating tasks multiple times when reached
+		# through multiple dependency paths before the event loop runs.
+		# Once the task starts running, new push_change calls will cancel and restart.
+		if self._task is not None and not self._task.done() and not self._task_started:
+			return
+		self.schedule()
+
 	@override
 	def schedule(self):
 		"""
@@ -525,13 +583,14 @@ class AsyncEffect(Effect):
 		"""
 		execution_epoch = epoch()
 
-		# Cancel any previous run still in flight
-		self.cancel()
+		# Cancel any previous run still in flight, but preserve the interval
+		self.cancel(cancel_interval=False)
 		this_task: asyncio.Task[None] | None = None
 
 		async def _runner():
 			nonlocal execution_epoch, this_task
 			try:
+				self._task_started = True
 				# Perform cleanups in the new task
 				with Untrack():
 					try:
@@ -558,10 +617,14 @@ class AsyncEffect(Effect):
 					self.runs += 1
 					self.last_run = execution_epoch
 				self._apply_scope_results(scope, captured_last_changes)
+				# Start/restart interval if set and not currently scheduled
+				if self._interval is not None and self._interval_handle is None:
+					self._schedule_interval()
 			finally:
 				# Clear the task reference when it finishes
 				if self._task is this_task:
 					self._task = None
+					self._task_started = False
 
 		this_task = create_task(_runner(), name=f"effect:{self.name or 'unnamed'}")
 		self._task = this_task
@@ -571,23 +634,34 @@ class AsyncEffect(Effect):
 	async def __call__(self):  # pyright: ignore[reportIncompatibleMethodOverride]
 		await self.run()
 
-	def cancel(self) -> None:
-		# No batch removal needed as AsyncEffect is not batched
+	@override
+	def cancel(self, cancel_interval: bool = True) -> None:
+		"""
+		Cancel the async effect. Cancels the running task and optionally the interval.
+
+		Args:
+			cancel_interval: If True (default), also cancels the interval timer.
+		"""
 		if self._task:
 			t = self._task
 			self._task = None
 			if not t.cancelled():
 				t.cancel()
+		if cancel_interval:
+			self._cancel_interval()
 
 	async def wait(self) -> None:
 		"""
-		Wait until the completion of the current task if it's already running,
-		or start a run if it's not running. In case of cancellation, awaits
-		the new task by recursively calling itself.
+		Wait until the completion of the current task if it's already running.
+		Does not start a new task if none is running.
+		If the task is cancelled while waiting, waits for a new task if one is started.
 		"""
 		while True:
+			if self._task is None or self._task.done():
+				# No task running, return immediately
+				return
 			try:
-				await (self._task or self.run())
+				await self._task
 				return
 			except asyncio.CancelledError:
 				# If wait() itself is cancelled, propagate it
@@ -596,13 +670,14 @@ class AsyncEffect(Effect):
 					current_task.cancelling() > 0 or current_task.cancelled()
 				):
 					raise
-				# Effect task was cancelled, continue waiting for new task
+				# Effect task was cancelled, check if a new task was started
+				# and continue waiting if so
 				continue
 
 	@override
 	def dispose(self):
-		# Run children cleanups first, then cancel in-flight task
-		self.cancel()
+		# Run children cleanups first, then cancel in-flight task and interval
+		self.cancel(cancel_interval=True)
 		for child in self.children.copy():
 			child.dispose()
 		if self.cleanup_fn:

pulse/reactive_extensions.py

@@ -405,18 +405,19 @@ class ReactiveList(list[T1]):
 	- Setting an index writes to that index's Signal
 	- Structural operations (append/insert/pop/remove/clear/extend/sort/reverse/slice assigns)
 	  trigger a structural version Signal so consumers can listen for changes that affect layout
-	- Iteration and len are NOT reactive; prefer explicit index reads inside render/effects
+	- Iteration subscribes to all item signals and structural changes
+	- len() subscribes to structural changes
 	"""
 
 	__slots__: tuple[str, ...] = ("_signals", "_structure")
 
-	def __init__(self, initial: Iterable[_Any] | None = None) -> None:
+	def __init__(self, initial: Iterable[T1] | None = None) -> None:
 		super().__init__()
-		self._signals: list[Signal[_Any]] = []
+		self._signals: list[Signal[T1]] = []
 		self._structure: Signal[int] = Signal(0)
 		if initial:
 			for item in initial:
-				v = cast(_Any, reactive(item))
+				v = reactive(item)
 				self._signals.append(Signal(v))
 				super().append(v)
 
@@ -617,7 +618,8 @@ class ReactiveList(list[T1]):
 	@override
 	def __iter__(self) -> Iterator[T1]:
 		self._structure.read()
-		return super().__iter__()
+		for sig in self._signals:
+			yield sig.read()
 
 	def __copy__(self):
 		result = type(self)()
@@ -640,7 +642,7 @@ class ReactiveSet(set[T1]):
 
 	- `x in s` reads a membership Signal for element `x`
 	- Mutations update membership Signals for affected elements
-	- Iteration and len are NOT reactive
+	- Iteration subscribes to membership signals for all elements
 	"""
 
 	__slots__: tuple[str, ...] = ("_signals",)
@@ -664,6 +666,12 @@ class ReactiveSet(set[T1]):
 			sig = self._signals[element]
 		return bool(sig.read())
 
+	@override
+	def __iter__(self) -> Iterator[T1]:
+		# Subscribe to membership signals and return present elements
+		present = [elem for elem, sig in self._signals.items() if sig.read()]
+		return iter(present)
+
 	@override
 	def add(self, element: T1) -> None:
 		element = reactive(element)
@@ -1068,7 +1076,11 @@ def unwrap(value: _Any, untrack: bool = False) -> _Any:
 			return {k: _unwrap(val) for k, val in v.items()}
 		if isinstance(v, Sequence) and not isinstance(v, (str, bytes, bytearray)):
 			if isinstance(v, tuple):
-				return tuple(_unwrap(val) for val in v)
+				# Preserve namedtuple types
+				if hasattr(v, "_fields"):
+					return type(v)(*(_unwrap(val) for val in v))
+				else:
+					return tuple(_unwrap(val) for val in v)
 			return [_unwrap(val) for val in v]
 		if isinstance(v, set):
 			return {_unwrap(val) for val in v}

pulse/state.py

@@ -80,6 +80,7 @@ class StateEffect(Generic[T], InitializableProperty):
 	on_error: "Callable[[Exception], None] | None"
 	lazy: bool
 	deps: "list[Signal[Any] | Computed[Any]] | None"
+	interval: float | None
 
 	def __init__(
 		self,
@@ -89,6 +90,7 @@ class StateEffect(Generic[T], InitializableProperty):
 		lazy: bool = False,
 		on_error: "Callable[[Exception], None] | None" = None,
 		deps: "list[Signal[Any] | Computed[Any]] | None" = None,
+		interval: float | None = None,
 	):
 		self.fn = fn
 		self.name = name
@@ -96,6 +98,7 @@ class StateEffect(Generic[T], InitializableProperty):
 		self.on_error = on_error
 		self.lazy = lazy
 		self.deps = deps
+		self.interval = interval
 
 	@override
 	def initialize(self, state: "State", name: str):
@@ -108,6 +111,7 @@ class StateEffect(Generic[T], InitializableProperty):
 				lazy=self.lazy,
 				on_error=self.on_error,
 				deps=self.deps,
+				interval=self.interval,
 			)
 		else:
 			effect = Effect(
@@ -117,6 +121,7 @@ class StateEffect(Generic[T], InitializableProperty):
 				lazy=self.lazy,
 				on_error=self.on_error,
 				deps=self.deps,
+				interval=self.interval,
 			)
 		setattr(state, name, effect)
 

{pulse_framework-0.1.42.dist-info → pulse_framework-0.1.43.dist-info}/METADATA

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

{pulse_framework-0.1.42.dist-info → pulse_framework-0.1.43.dist-info}/RECORD

@@ -1,4 +1,4 @@
-pulse/__init__.py,sha256=w7LVrYNiho18v9JyDQ8DZGdBYV4dZYtlEFiRi32ICiw,32166
+pulse/__init__.py,sha256=Acb_t45WP9HsPBRBtKsx5rj-u-pl8gRmdwsKKVPokK4,32721
 pulse/app.py,sha256=cVEqazFcgSnmZSxqqz6HWk2QsI8rnKbO7Y_L88BcHSc,32082
 pulse/channel.py,sha256=d9eLxgyB0P9UBVkPkXV7MHkC4LWED1Cq3GKsEu_SYy4,13056
 pulse/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -27,10 +27,10 @@ pulse/components/react_router.py,sha256=TbRec-NVliUqrvAMeFXCrnDWV1rh6TGTPfRhqLuL
 pulse/context.py,sha256=fMK6GdQY4q_3452v5DJli2f2_urVihnpzb-O-O9cJ1Q,1734
 pulse/cookies.py,sha256=c7ua1Lv6mNe1nYnA4SFVvewvRQAbYy9fN5G3Hr_Dr5c,5000
 pulse/css.py,sha256=-FyQQQ0EZI1Ins30qiF3l4z9yDb1V9qWuJKWxHcKGkw,3910
-pulse/decorators.py,sha256=hRfgb9XU1yizmtdhuBln_3Gy-Cz2Smo4rYvAqlURrLQ,9348
+pulse/decorators.py,sha256=ywNgLN6VFcKOM5fbFdUUzh-DWk4BuSXdD1BTfd1N-0U,4827
 pulse/env.py,sha256=p3XI8KG1ZCcXPD3LJP7fW8JPYfyvoYY5ENwae2o0PiA,2889
 pulse/form.py,sha256=P7W8guUdGbgqNOk8cSUCWuY6qWre0me6_fypv1qOvqw,8987
-pulse/helpers.py,sha256=BBtf--LZxvfpwJU8p92QrZWtOKIWfB3DOiAtGxhet90,13232
+pulse/helpers.py,sha256=aF0SD3z2oGWFRt3BUhoI8JU5SwDAy1a4eg9BaW0LTUg,13745
 pulse/hooks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pulse/hooks/core.py,sha256=JTZbVxNOEs_GAeK6Bh6hemSTkgwZPtEi_wt55cvOdik,7381
 pulse/hooks/effects.py,sha256=CQvt5viAweGLSxaGGlWm155GlEQiwQnGussw7OfiCGc,2393
@@ -52,26 +52,28 @@ pulse/plugin.py,sha256=RfGl6Vtr7VRHb8bp4Ob4dOX9dVzvc4Riu7HWnStMPpk,580
 pulse/proxy.py,sha256=zh4v5lmYNg5IBE_xdHHmGPwbMQNSXb2npeLXvw_O1Oc,6591
 pulse/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pulse/queries/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pulse/queries/common.py,sha256=2_11SEOFrDbe_ULNSA9EWeOkvz-xym5hCuX4bW455t0,556
-pulse/queries/mutation.py,sha256=_0-o2g2yux52hTsRLGuWwFUdGrBx9YJqi67oBw9iNcc,4209
-pulse/queries/query.py,sha256=WxBEaEjtzDGWWKpSi8-xl9xBvPvREYH1Tonl_lOY-VQ,7347
-pulse/queries/query_observer.py,sha256=Wd3pk5OsZB_ze6DnpOkASv4Ny5EuSbwUlUEPXIXxSgk,10229
-pulse/queries/store.py,sha256=ylSCOHiXp8vEyEWc5Et8zLWkyHj5OQYKOVfs0OehpX8,1465
+pulse/queries/client.py,sha256=hZB3rAfH_fl_6ld_s9z81Vxvt8Cg0gXWU4Gj1qAL0LE,15254
+pulse/queries/common.py,sha256=Cr_NV0dWz5DQ7Qg771jvUms1o2-EnTYqjZJe4tVeoVk,1160
+pulse/queries/effect.py,sha256=8U7iAo3B4WB5lIcT6bE7YRnyfEYTLzNESq9KdDQsVYA,835
+pulse/queries/infinite_query.py,sha256=XBMuVApwBnzsB-toQfsyYRziMwtQhQq8wjtBzCq0qv4,36098
+pulse/queries/mutation.py,sha256=_WVRFU4BwkHrHQjEZc2mjyZTUx9Pad73xFWaFPF7I1Y,5315
+pulse/queries/query.py,sha256=MEKV8eKANFQmiWWs12ytgD9szYNbR2226EW_DkoFiNo,22037
+pulse/queries/store.py,sha256=p_WO7X-REytwkEyGjJi6XDv9tlrJX0v6E1sk1bBrPqM,3541
 pulse/react_component.py,sha256=hPibKBEkVdpBKNSpMQ6bZ-7GnJQcNQwcw2SvfY1chHA,26026
-pulse/reactive.py,sha256=cKZDafbUQFdnNRAxI71THnsFZEbWZ5mU06pMuP6spo8,21187
-pulse/reactive_extensions.py,sha256=gTLkQ0urwANjWNHWMkg-P9zvpevHCnNKd5BSM8G0pno,31521
+pulse/reactive.py,sha256=0CqzeowZHAENMxM2PFhi_Q6KkDzG844JofzDk0Wxckw,23961
+pulse/reactive_extensions.py,sha256=WAx4hlB1ByZLFVpgtRnaWXAQ3N2QQplf647oQXDL5vg,31901
 pulse/render_session.py,sha256=kqLfZ9AxCrB2mIJqegATL1KA7CI-LZSBQwRYr7Uxo9g,14581
 pulse/renderer.py,sha256=dJiX9VeHr9kC1UBw5oaKB8Mv-3OCMGTrHiKgLJ5FL50,16759
 pulse/request.py,sha256=sPsSRWi5KvReSPBLIs_kzqomn1wlRk1BTLZ5s0chQr4,4979
 pulse/routing.py,sha256=RlrGHyK4F28_zUHMYNeKp4pNbvqrt4GY4t5xNdhzunI,13926
 pulse/serializer.py,sha256=8RAITNoSNm5-U38elHpWmkBpcM_rxZFMCluJSfldfk4,5420
-pulse/state.py,sha256=mytXlQjmLIBjB2XDgCg9E1fHCcyoNQ02cBqZ_vldxuc,10636
+pulse/state.py,sha256=ikQbK4R8PieV96qd4uWREUvs0jXo9sCapawY7i6oCYo,10776
 pulse/types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pulse/types/event_handler.py,sha256=tfKa6OEA5XvzuYbllQZJ03ooN7rGSYOtaPBstSL4OLU,1642
 pulse/user_session.py,sha256=Nn9ZZha1Rruw31OSoK14QaEL0erGVFbryFhJYrtMZsQ,7599
 pulse/vdom.py,sha256=1UAjOYSmpdZeSVELqejh47Jer4mA73T_q2HtAogOphs,12514
 pulse/version.py,sha256=711vaM1jVIQPgkisGgKZqwmw019qZIsc_QTae75K2pg,1895
-pulse_framework-0.1.42.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
-pulse_framework-0.1.42.dist-info/entry_points.txt,sha256=i7aohd3QaPu5IcuGKKvsQQEiMYMe5HcF56QEsaLVO64,46
-pulse_framework-0.1.42.dist-info/METADATA,sha256=Pyy5qb02JHkAFwGpy6m8SkrlPH_mmL6BPxDfvQ41ly4,580
-pulse_framework-0.1.42.dist-info/RECORD,,
+pulse_framework-0.1.43.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+pulse_framework-0.1.43.dist-info/entry_points.txt,sha256=i7aohd3QaPu5IcuGKKvsQQEiMYMe5HcF56QEsaLVO64,46
+pulse_framework-0.1.43.dist-info/METADATA,sha256=sXMEvuwI6Pa_bnIgQyYUdhhnBpEXXrtQFWtXG13xMls,580
+pulse_framework-0.1.43.dist-info/RECORD,,