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

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.66a1.dist-info}/METADATA

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

{pulse_framework-0.1.64.dist-info → pulse_framework-0.1.66a1.dist-info}/RECORD

@@ -1,7 +1,7 @@
-pulse/__init__.py,sha256=hf1FFA4EDRxFNiPQoKwQfNHtnCf4UT7STqzgbjJ7dgI,32043
+pulse/__init__.py,sha256=cXNVXz0aizbkOG1aj2zytgzodyVNv7nNylsXcWmH-Lc,32183
 pulse/_examples.py,sha256=dFuhD2EVXsbvAeexoG57s4VuN4gWLaTMOEMNYvlPm9A,561
-pulse/app.py,sha256=KnP6U8uHgfBbFMguDcVk0KgjakY1UC1NJk2rS5l6Sas,35145
-pulse/channel.py,sha256=sQrDLh3k9Z8CyJQkEHzKu4h-yR4XSTgAA3OCQax3Ciw,15766
+pulse/app.py,sha256=oVwe7ioAGl7OXIEiT8J0bj5GBxEkBroOJw6qgdyA7Bg,37343
+pulse/channel.py,sha256=ePpvD2mDbddt_LMxxxDjNRgOLbVi8Ed6TmJFgkrALB0,15790
 pulse/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pulse/cli/cmd.py,sha256=zh3Ah6c16cNg3o_v_If_S58Qe8rvxNe5M2VrTkwvDU8,15957
 pulse/cli/dependencies.py,sha256=qU-rF7QyP0Rl1Fl0YKQubrGNBzj84BAbH1uUT3ehxik,4283
@@ -17,7 +17,7 @@ pulse/code_analysis.py,sha256=NBba_7VtOxZYMyfku_p-bWkG0O_1pi1AxcaNyVM1nmY,1024
 pulse/codegen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pulse/codegen/codegen.py,sha256=Zw55vzevg_17hFtSi6KLl-EWSiABKRfZe6fB-cWpLAk,10330
 pulse/codegen/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pulse/codegen/templates/layout.py,sha256=nmWPQcO9SRXc3mCCVLCmykreSF96TqQfdDY7dvUBxRg,4737
+pulse/codegen/templates/layout.py,sha256=xz2ImZrbpu-tUkHZ38U6npIDzeYhrR_s41BuNPJUnOU,4470
 pulse/codegen/templates/route.py,sha256=UjBrb3e_8tMkd1OjBjEsnYmK6PCQqOYZBWDuU59FcrI,9234
 pulse/codegen/templates/routes_ts.py,sha256=nPgKCvU0gzue2k6KlOL1TJgrBqqRLmyy7K_qKAI8zAE,1129
 pulse/codegen/utils.py,sha256=QoXcV-h-DLLmq_t03hDNUePS0fNnofUQLoR-TXzDFCY,539
@@ -37,8 +37,8 @@ pulse/dom/svg.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pulse/dom/tags.py,sha256=U6mKmwB9JAFM6LTESMJcoIejNfnyxIdQo2-TLM5OaZ0,7585
 pulse/dom/tags.pyi,sha256=0BC7zTh22roPBuMQawL8hgI6IrfN8xJZuDIoKMd4QKc,14393
 pulse/env.py,sha256=etfubfwq7VWlo2iKy_972WtHZSiVe4StAnjFga0xgj8,4244
-pulse/form.py,sha256=dzzcxuIkA8EOAETrbMV916Jv_tlgVuoBKfgL3P2MySo,14058
-pulse/helpers.py,sha256=feHkC2g3DgfGN7FrvgRPZjmXzBjBYXwFu6wRPdy3w_I,15056
+pulse/forms.py,sha256=0irpErCMJk8-YO1BrxjMkFb8dnvSz3rfzTywmMeib7g,14042
+pulse/helpers.py,sha256=imVA9XzkYrYmdeqEdD7ot0g99adL1SVKv5bQGkKb-aQ,9504
 pulse/hooks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pulse/hooks/core.py,sha256=tDEcB_CTD4yI5bNKn7CtB40sRKIanGNqPD5_qLgSzf4,10982
 pulse/hooks/effects.py,sha256=cEPurXwRQoFmxasI0tZE1cQsZYnZr6VB5mWMUK0Db8c,2604
@@ -74,25 +74,26 @@ pulse/js/window.py,sha256=yC1BjyH2jqp1x-CXJCUFta-ASyZ5668ozQ0AmAjZcxA,4097
 pulse/messages.py,sha256=hz5EUFVHbzXHkcByZcV_Y199vb-M9cGjMMBL1HXPctE,4024
 pulse/middleware.py,sha256=2syzmJ0r9fEa0k1pD7zC_1DHUMs9qLSWRzo5XXtKqsA,10896
 pulse/plugin.py,sha256=bu90qaUVFtZsIsW41dpshVK1vvIGHUsg6mFoiF0Wfso,2370
-pulse/proxy.py,sha256=Rj0hOVnwyI36lrkK9fEKAgFK-WCwt5X526J87A2EvMs,7773
+pulse/proxy.py,sha256=tj30GIJJVNKMxMwPNJ39-gn3PAXbx5wua4PiQ7XupvQ,7857
 pulse/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pulse/queries/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pulse/queries/client.py,sha256=AW42ZPdZJfDkCERpoxQnsiU5cYLfOlZX0sIb9BdIL4E,18495
+pulse/queries/client.py,sha256=52T4MvorDr-T5UsJlndcEgnrPDs3QxIYP-MZtBSEuvc,18583
 pulse/queries/common.py,sha256=TYhn6LyldfmOKYYurxINgCEr3C3WSEwB0cIki1a5iBM,2488
-pulse/queries/effect.py,sha256=7KvV_yK7OHTWhfQbZFGzg_pRhyI2mn25pKIF9AmSmcU,1471
-pulse/queries/infinite_query.py,sha256=3_gv_pDTShNDf_y2yQ-QLDskJOxXhg1dOmQbU2_QxhE,48101
+pulse/queries/effect.py,sha256=1ePUi2TwP49L9LhlkKI2qV_HhIO4jKj1r5jyPaWiUn8,1508
+pulse/queries/infinite_query.py,sha256=xWmFl5UqW7DXkquR-8EUPqlS6Z-ZF4l7qarEUUXjdN0,49091
 pulse/queries/mutation.py,sha256=fhEpOZ7CuHImH4Y02QapYdTJrwe6K52-keb0d67wmms,8274
 pulse/queries/protocol.py,sha256=TOrUiI4QK55xuh0i4ch1u96apNl12QeYafkf6RVDd08,3544
-pulse/queries/query.py,sha256=bKtsbsYGy53s8Fq-33OY0od8p9GKbXmiKR0Ob-NRcPs,40735
-pulse/queries/store.py,sha256=Ct7a-h1-Cq07zEfe9vw-LM85Fm7jIJx7CLAIlsiznlU,3444
+pulse/queries/query.py,sha256=2VlYMeLqHfEokoEtocKjld8zi6Oy-_lieV4baTfF5DU,41332
+pulse/queries/store.py,sha256=4pWTDSl71LUM7YqhWanKjZkFh3t8F_04o48js_H4ttQ,3728
 pulse/react_component.py,sha256=8RLg4Bi7IcjqbnbEnp4hJpy8t1UsE7mG0UR1Q655LDk,2332
-pulse/reactive.py,sha256=FxxpH7NBtQr7G89iCVN7y1EG21f23GcRi1M-XIxcRQA,31280
+pulse/reactive.py,sha256=GSh9wSH3THCBjDTafwWttyx7djeKBWV_KqjaKRYUNsA,31393
 pulse/reactive_extensions.py,sha256=yQ1PpdAh4kMvll7R15T72FOg8NFdG_HGBsGc63dawYk,33754
-pulse/render_session.py,sha256=9gfwuBZRCWuQMN_nFuaAi__1UPN3I3C1mKWtAXyA3-A,21340
+pulse/render_session.py,sha256=w6eJcMt4VFu84HeBAmBeEogxPtiwRHnRgQSTabrSXQM,24889
 pulse/renderer.py,sha256=fjSsUvCqV12jyN7Y5XspKUfjQJJzKX-Chha5oF5PrAk,16001
 pulse/request.py,sha256=N0oFOLiGxpbgSgxznjvu64lG3YyOcZPKC8JFyKx6X7w,6023
 pulse/requirements.py,sha256=nMnE25Uu-TUuQd88jW7m2xwus6fD-HvXxQ9UNb7OOGc,1254
 pulse/routing.py,sha256=LzTITvGgaLI1w7qTDZjFwoBcWAb4O8Dz7AmXeTNYrFU,16903
+pulse/scheduling.py,sha256=D-L5mVsbakK_-1NCq62dU6wEJpq6I_HxI4PCmR9aj9w,11714
 pulse/serializer.py,sha256=HmQZgxQiaCx2SL2XwmEQLd_xsk_P8XfLtGciLLLOxx0,7616
 pulse/state.py,sha256=VMphVpYNU1CyHMMg1_kNJO3cfqLXJPAuq9gr9RYyUAw,15922
 pulse/test_helpers.py,sha256=4iO5Ymy3SMvSjh-UaAaSdqm1I_SAJMNjdY2iYVro5f8,436
@@ -121,7 +122,7 @@ pulse/types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pulse/types/event_handler.py,sha256=psQCydj-WEtBcFU5JU4mDwvyzkW8V2O0g_VFRU2EOHI,1618
 pulse/user_session.py,sha256=nsnsMgqq2xGJZLpbHRMHUHcLrElMP8WcA4gjGMrcoBk,10208
 pulse/version.py,sha256=711vaM1jVIQPgkisGgKZqwmw019qZIsc_QTae75K2pg,1895
-pulse_framework-0.1.64.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
-pulse_framework-0.1.64.dist-info/entry_points.txt,sha256=i7aohd3QaPu5IcuGKKvsQQEiMYMe5HcF56QEsaLVO64,46
-pulse_framework-0.1.64.dist-info/METADATA,sha256=vngWZz-tQp2X0ijnpp71j-4W1pRv8_JZCYlU0smMZE4,8300
-pulse_framework-0.1.64.dist-info/RECORD,,
+pulse_framework-0.1.66a1.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+pulse_framework-0.1.66a1.dist-info/entry_points.txt,sha256=i7aohd3QaPu5IcuGKKvsQQEiMYMe5HcF56QEsaLVO64,46
+pulse_framework-0.1.66a1.dist-info/METADATA,sha256=5eOY1sXHWh-_WZB1EUlHxRKoqU3jIAJH0_iqQ2niZhI,8302
+pulse_framework-0.1.66a1.dist-info/RECORD,,