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

pulse/__init__.py

@@ -1410,6 +1410,7 @@ from pulse.render_session import run_js as run_js
 
 # Request
 from pulse.request import PulseRequest as PulseRequest
+from pulse.requirements import require as require
 from pulse.routing import Layout as Layout
 from pulse.routing import Route as Route
 from pulse.routing import RouteInfo as RouteInfo

pulse/cli/dependencies.py

@@ -11,11 +11,10 @@ from pulse.cli.packages import (
 	is_workspace_spec,
 	load_package_json,
 	parse_dependency_spec,
-	parse_install_spec,
 	resolve_versions,
 	spec_satisfies,
 )
-from pulse.transpiler.imports import get_registered_imports
+from pulse.requirements import get_requirements
 
 
 def convert_pep440_to_semver(python_version: str) -> str:
@@ -98,20 +97,12 @@ def get_required_dependencies(
 		"pulse-ui-client": [pulse_version],
 	}
 
-	# New transpiler v2 imports
-	for imp in get_registered_imports():
-		if imp.src:
-			try:
-				spec = parse_install_spec(imp.src)
-			except ValueError as exc:
-				# We might want to be more lenient here or at least log it,
-				# but following existing pattern of raising DependencyError
-				raise DependencyError(str(exc)) from None
-			if spec:
-				name_only, ver = parse_dependency_spec(spec)
-				constraints.setdefault(name_only, []).append(ver)
-				if imp.version:
-					constraints.setdefault(name_only, []).append(imp.version)
+	for src, version in get_requirements():
+		name_only, ver_in_src = parse_dependency_spec(src)
+		if ver_in_src:
+			constraints.setdefault(name_only, []).append(ver_in_src)
+		if version:
+			constraints.setdefault(name_only, []).append(version)
 
 	try:
 		resolved = resolve_versions(constraints)

pulse/component.py

@@ -112,7 +112,7 @@ class Component(Generic[P]):
 			flattened = flatten_children(
 				args,  # pyright: ignore[reportArgumentType]
 				parent_name=f"<{self.name}>",
-				warn_stacklevel=4,
+				warn_stacklevel=None,
 			)
 			args = tuple(flattened)  # pyright: ignore[reportAssignmentType]
 

pulse/queries/infinite_query.py

@@ -152,6 +152,61 @@ class InfiniteQuery(Generic[T, TParam], 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, "InfiniteQueryResult[T, TParam] | None"]:
+		min_interval: float | None = None
+		selected: "InfiniteQueryResult[T, TParam] | 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
+			self.invalidate(fetch_fn=observer._fetch_fn, observer=observer)  # pyright: ignore[reportPrivateUsage]
+
+		return Effect(
+			interval_fn,
+			name=f"inf_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)
+
 	# Reactive state
 	pages: ReactiveList[Page[T, TParam]]
 	error: Signal[Exception | None]
@@ -171,6 +226,9 @@ class InfiniteQuery(Generic[T, TParam], Disposable):
 
 	_observers: "list[InfiniteQueryResult[T, TParam]]"
 	_gc_handle: asyncio.TimerHandle | None
+	_interval_effect: Effect | None
+	_interval: float | None
+	_interval_observer: "InfiniteQueryResult[T, TParam] | None"
 
 	def __init__(
 		self,
@@ -232,6 +290,9 @@ class InfiniteQuery(Generic[T, TParam], Disposable):
 		self._queue_task = None
 		self._observers = []
 		self._gc_handle = None
+		self._interval_effect = None
+		self._interval = None
+		self._interval_observer = None
 
 	# ─────────────────────────────────────────────────────────────────────────
 	# Commit functions - update state after pages have been modified
@@ -326,13 +387,7 @@ class InfiniteQuery(Generic[T, TParam], Disposable):
 		fetch_fn: Callable[[TParam], Awaitable[T]] | None = None,
 		observer: "InfiniteQueryResult[T, TParam] | None" = None,
 	) -> ActionResult[list[Page[T, TParam]]]:
-		"""Wait for initial data or until queue is empty."""
-		# If no data and loading, enqueue initial fetch (unless already processing)
-		if len(self.pages) == 0 and self.status() == "loading":
-			if self._queue_task is None or self._queue_task.done():
-				# Use provided fetch_fn or fall back to first observer's fetch_fn
-				fn = fetch_fn if fetch_fn is not None else self.fn
-				self._enqueue(Refetch(fetch_fn=fn, observer=observer))
+		"""Wait for any in-flight queue processing to complete."""
 		# Wait for any in-progress queue processing
 		if self._queue_task and not self._queue_task.done():
 			await self._queue_task
@@ -341,17 +396,31 @@ class InfiniteQuery(Generic[T, TParam], Disposable):
 			return ActionError(cast(Exception, self.error()))
 		return ActionSuccess(list(self.pages))
 
+	async def ensure(
+		self,
+		fetch_fn: Callable[[TParam], Awaitable[T]] | None = None,
+		observer: "InfiniteQueryResult[T, TParam] | None" = None,
+	) -> ActionResult[list[Page[T, TParam]]]:
+		"""Ensure an initial fetch has started, then wait for completion."""
+		if len(self.pages) == 0 and self.status() == "loading":
+			if self._queue_task is None or self._queue_task.done():
+				fn = fetch_fn if fetch_fn is not None else self.fn
+				self._enqueue(Refetch(fetch_fn=fn, observer=observer))
+		return await self.wait()
+
 	def observe(self, observer: Any):
 		self._observers.append(observer)
 		self.cancel_gc()
 		gc_time = getattr(observer, "_gc_time", 0)
 		if gc_time and gc_time > 0:
 			self.cfg.gc_time = max(self.cfg.gc_time, gc_time)
+		self._update_interval()
 
 	def unobserve(self, observer: "InfiniteQueryResult[T, TParam]"):
 		"""Unregister an observer. Cancels pending actions. Schedules GC if no observers remain."""
 		if observer in self._observers:
 			self._observers.remove(observer)
+		self._update_interval()
 
 		# Cancel pending actions from this observer
 		self._cancel_observer_actions(observer)
@@ -630,11 +699,17 @@ class InfiniteQuery(Generic[T, TParam], Disposable):
 			(i for i, p in enumerate(self.pages) if p.param == action.param),
 			None,
 		)
-		if idx is None:
-			return None
 
 		page = await action.fetch_fn(action.param)
-		self.pages[idx] = Page(page, action.param)
+
+		if idx is None:
+			# Page doesn't exist - jump to this page, clearing existing pages
+			self.pages.clear()
+			self.pages.append(Page(page, action.param))
+		else:
+			# Page exists, update it
+			self.pages[idx] = Page(page, action.param)
+
 		await self.commit()
 		return page
 
@@ -708,7 +783,10 @@ class InfiniteQuery(Generic[T, TParam], Disposable):
 		cancel_fetch: bool = False,
 	) -> ActionResult[T | None]:
 		"""
-		Refetch an existing page by its param. Queued for sequential execution.
+		Refetch a page by its param. Queued for sequential execution.
+
+		If the page doesn't exist, clears existing pages and loads the requested
+		page as the new starting point.
 
 		Note: Prefer calling refetch_page() on InfiniteQueryResult to ensure the
 		correct fetch function is used. When called directly on InfiniteQuery, uses
@@ -725,6 +803,9 @@ class InfiniteQuery(Generic[T, TParam], Disposable):
 		self._cancel_queue()
 		if self._queue_task and not self._queue_task.done():
 			self._queue_task.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)
 
@@ -778,7 +859,6 @@ class InfiniteQueryResult(Generic[T, TParam], Disposable):
 	_on_success: Callable[[list[Page[T, TParam]]], Awaitable[None] | None] | None
 	_on_error: Callable[[Exception], Awaitable[None] | None] | None
 	_observe_effect: Effect
-	_interval_effect: Effect | None
 	_data_computed: Computed[list[Page[T, TParam]] | None]
 	_enabled: Signal[bool]
 	_fetch_on_mount: bool
@@ -801,13 +881,17 @@ class InfiniteQueryResult(Generic[T, TParam], 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"inf_query.enabled({query().key})")
 		self._fetch_on_mount = fetch_on_mount
-		self._interval_effect = None
 
 		def observe_effect():
 			q = self._query()
@@ -816,8 +900,13 @@ class InfiniteQueryResult(Generic[T, TParam], Disposable):
 			with Untrack():
 				q.observe(self)
 
-				if enabled and fetch_on_mount and self.is_stale():
-					q.invalidate()
+				# Skip if query interval is active - interval effect handles initial fetch
+				if enabled and fetch_on_mount and not q.has_interval:
+					# Fetch if no data loaded yet or if existing data is stale
+					if not q.is_fetching() and (
+						q.status() == "loading" or self.is_stale()
+					):
+						q.invalidate()
 
 			# Return cleanup function that captures the query (old query on key change)
 			def cleanup():
@@ -834,25 +923,6 @@ class InfiniteQueryResult(Generic[T, TParam], Disposable):
 			self._data_computed_fn, name=f"inf_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._query().invalidate()
-
-		self._interval_effect = Effect(
-			interval_fn,
-			name=f"inf_query_interval({self._query().key})",
-			interval=interval,
-			immediate=True,
-		)
-
 	@property
 	def status(self) -> QueryStatus:
 		return self._query().status()
@@ -985,15 +1055,20 @@ class InfiniteQueryResult(Generic[T, TParam], Disposable):
 	async def wait(self) -> ActionResult[list[Page[T, TParam]]]:
 		return await self._query().wait(fetch_fn=self._fetch_fn, observer=self)
 
+	async def ensure(self) -> ActionResult[list[Page[T, TParam]]]:
+		return await self._query().ensure(fetch_fn=self._fetch_fn, observer=self)
+
 	def invalidate(self):
 		query = self._query()
 		query.invalidate(fetch_fn=self._fetch_fn, observer=self)
 
 	def enable(self):
 		self._enabled.write(True)
+		self._query()._update_interval()  # pyright: ignore[reportPrivateUsage]
 
 	def disable(self):
 		self._enabled.write(False)
+		self._query()._update_interval()  # pyright: ignore[reportPrivateUsage]
 
 	def set_error(self, error: Exception):
 		query = self._query()
@@ -1002,8 +1077,6 @@ class InfiniteQueryResult(Generic[T, TParam], Disposable):
 	@override
 	def dispose(self):
 		"""Clean up the result and its observe effect."""
-		if self._interval_effect is not None:
-			self._interval_effect.dispose()
 		self._observe_effect.dispose()
 
 

pulse/queries/protocol.py

@@ -90,6 +90,15 @@ class QueryResult(Protocol[T]):
 		"""
 		...
 
+	async def ensure(self) -> ActionResult[T]:
+		"""
+		Ensure an initial fetch has started, then wait for completion.
+
+		Returns:
+		    ActionResult containing either the data or an error.
+		"""
+		...
+
 	def invalidate(self) -> None:
 		"""Mark the query as stale and trigger a refetch if observed."""
 		...

pulse/queries/query.py

@@ -268,6 +268,9 @@ class KeyedQuery(Generic[T], Disposable):
 	_task: asyncio.Task[None] | None
 	_task_initiator: "KeyedQueryResult[T] | None"
 	_gc_handle: asyncio.TimerHandle | None
+	_interval_effect: Effect | None
+	_interval: float | None
+	_interval_observer: "KeyedQueryResult[T] | None"
 
 	def __init__(
 		self,
@@ -293,6 +296,9 @@ 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
@@ -438,6 +444,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 +534,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 +573,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)
 
@@ -559,7 +630,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
@@ -581,12 +657,13 @@ class UnkeyedQueryResult(Generic[T], Disposable):
 
 		# 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."""
@@ -699,15 +776,18 @@ 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()))
 
+	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."""
 		if not self.is_scheduled:
@@ -740,7 +820,6 @@ 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]
 	_enabled: Signal[bool]
 	_fetch_on_mount: bool
@@ -762,12 +841,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 +859,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():
@@ -795,25 +880,6 @@ class KeyedQueryResult(Generic[T], Disposable):
 			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,
-		)
-
 	@property
 	def status(self) -> QueryStatus:
 		return self._query().status()
@@ -874,9 +940,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 +979,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()
 

pulse/requirements.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+
+_REQUIREMENTS: list[tuple[str, str]] = []
+
+
+def add_requirement(name: str, version: str) -> None:
+	if not name or not version:
+		return
+	_REQUIREMENTS.append((name, version))
+
+
+def register_requirements(packages: Mapping[str, str]) -> None:
+	for name, version in packages.items():
+		if not name or not version:
+			continue
+		add_requirement(name, version)
+
+
+def get_requirements() -> list[tuple[str, str]]:
+	return list(_REQUIREMENTS)
+
+
+def clear_requirements() -> None:
+	_REQUIREMENTS.clear()
+
+
+def require(packages: Mapping[str, str]) -> None:
+	"""Register npm package version requirements for dependency syncing."""
+	if not isinstance(packages, Mapping):
+		raise TypeError("require expects a mapping of package names to versions")
+	if not packages:
+		return
+
+	normalized: dict[str, str] = {}
+	for name, version in packages.items():
+		if not isinstance(name, str) or not name.strip():
+			raise TypeError("require expects non-empty package names")
+		if not isinstance(version, str) or not version.strip():
+			raise TypeError(f"require expects a version string for {name!r}")
+		normalized[name.strip()] = version.strip()
+
+	register_requirements(normalized)
+
+
+__all__ = ["require"]

pulse/transpiler/imports.py

@@ -14,7 +14,8 @@ from typing import (
 )
 from typing import Literal as Lit
 
-from pulse.cli.packages import pick_more_specific
+from pulse.cli.packages import parse_dependency_spec, pick_more_specific
+from pulse.requirements import add_requirement, clear_requirements
 from pulse.transpiler.assets import LocalAsset, register_local_asset
 from pulse.transpiler.errors import TranspileError
 from pulse.transpiler.id import next_id
@@ -131,6 +132,14 @@ _ImportKey: TypeAlias = tuple[str, str, str, bool]
 _IMPORT_REGISTRY: dict[_ImportKey, "Import"] = {}
 
 
+def _is_alias_path(path: str) -> bool:
+	return path.startswith("@/") or path.startswith("~/")
+
+
+def _is_url(path: str) -> bool:
+	return path.startswith("http://") or path.startswith("https://")
+
+
 def get_registered_imports() -> list["Import"]:
 	"""Get all registered imports."""
 	return list(_IMPORT_REGISTRY.values())
@@ -139,6 +148,7 @@ def get_registered_imports() -> list["Import"]:
 def clear_import_registry() -> None:
 	"""Clear the import registry."""
 	_IMPORT_REGISTRY.clear()
+	clear_requirements()
 
 
 @dataclass(slots=True, init=False)
@@ -240,6 +250,17 @@ class Import(Expr):
 				asset = register_local_asset(resolved)
 				import_src = str(resolved)
 
+		if (
+			not is_local_path(import_src)
+			and not _is_alias_path(import_src)
+			and not _is_url(import_src)
+		):
+			name_only, ver_in_src = parse_dependency_spec(import_src)
+			if ver_in_src:
+				add_requirement(name_only, ver_in_src)
+			if version:
+				add_requirement(name_only, version)
+
 		self.name = name
 		self.src = import_src
 		self.kind = kind

pulse/transpiler/nodes.py

@@ -7,7 +7,7 @@ import warnings
 from abc import ABC, abstractmethod
 from collections.abc import Callable, Iterable, Sequence
 from dataclasses import dataclass, field
-from inspect import isfunction, signature
+from inspect import currentframe, isfunction, signature
 from typing import (
 	TYPE_CHECKING,
 	Any,
@@ -540,15 +540,13 @@ class Element(Expr):
 			self.children = None
 		else:
 			if isinstance(tag, str):
-				parent_name = tag[2:] if tag.startswith("$$") else tag
+				parent_name: str | Expr = tag[2:] if tag.startswith("$$") else tag
 			else:
-				tag_out: list[str] = []
-				tag.emit(tag_out)
-				parent_name = "".join(tag_out)
+				parent_name = tag
 			self.children = flatten_children(
 				children,
 				parent_name=parent_name,
-				warn_stacklevel=5,
+				warn_stacklevel=None,
 			)
 		self.key = key
 
@@ -787,7 +785,7 @@ class PulseNode:
 		flat = flatten_children(
 			children_arg,
 			parent_name=parent_name,
-			warn_stacklevel=5,
+			warn_stacklevel=None,
 		)
 		return PulseNode(
 			fn=self.fn,
@@ -804,8 +802,8 @@ class PulseNode:
 def flatten_children(
 	children: Sequence[Node | Iterable[Node]],
 	*,
-	parent_name: str,
-	warn_stacklevel: int = 5,
+	parent_name: str | Expr,
+	warn_stacklevel: int | None = None,
 ) -> list[Node]:
 	if env.pulse_env == "dev":
 		return _flatten_children_dev(
@@ -835,13 +833,14 @@ def _flatten_children_prod(children: Sequence[Node | Iterable[Node]]) -> list[No
 def _flatten_children_dev(
 	children: Sequence[Node | Iterable[Node]],
 	*,
-	parent_name: str,
-	warn_stacklevel: int = 5,
+	parent_name: str | Expr,
+	warn_stacklevel: int | None = None,
 ) -> list[Node]:
 	flat: list[Node] = []
 	seen_keys: set[str] = set()
 
 	def visit(item: Node | Iterable[Node]) -> None:
+		nonlocal warn_stacklevel
 		if isinstance(item, dict):
 			raise TypeError("Dict is not a valid child")
 		if isinstance(item, Iterable) and not isinstance(item, str):
@@ -853,6 +852,32 @@ def _flatten_children_dev(
 					missing_key = True
 				visit(sub)  # type: ignore[arg-type]
 			if missing_key:
+				if warn_stacklevel is None:
+					stacklevel = 1
+					frame = currentframe()
+					if frame is not None:
+						frame = frame.f_back
+						internal_prefixes = (
+							"pulse",
+							"pulse_mantine",
+							"pulse_ag_grid",
+							"pulse_recharts",
+							"pulse_lucide",
+							"pulse_msal",
+							"pulse_aws",
+						)
+						while frame is not None:
+							module = frame.f_globals.get("__name__", "")
+							if module and not any(
+								module == prefix or module.startswith(f"{prefix}.")
+								for prefix in internal_prefixes
+							):
+								break
+							stacklevel += 1
+							frame = frame.f_back
+						if frame is not None:
+							stacklevel += 1
+					warn_stacklevel = stacklevel
 				clean_name = clean_element_name(parent_name)
 				warnings.warn(
 					(
@@ -888,7 +913,25 @@ def _flatten_children_dev(
 	return flat
 
 
-def clean_element_name(parent_name: str) -> str:
+def clean_element_name(parent_name: str | Expr) -> str:
+	def expr_name(expr: Expr) -> str:
+		while isinstance(expr, ExprWrapper):
+			expr = expr.expr
+		if isinstance(expr, Member):
+			base = expr_name(expr.obj)
+			return f"{base}.{expr.prop}" if base else expr.prop
+		if isinstance(expr, Identifier):
+			return expr.name
+		if expr.__class__.__name__ == "Import":
+			name = getattr(expr, "name", None)
+			if isinstance(name, str) and name:
+				return name
+		out: list[str] = []
+		expr.emit(out)
+		return "".join(out)
+
+	if isinstance(parent_name, Expr):
+		parent_name = expr_name(parent_name)
 	if parent_name.startswith("<") and parent_name.endswith(">"):
 		return parent_name
 	return f"<{parent_name}>"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pulse-framework
-Version: 0.1.62
+Version: 0.1.64
 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.62.dist-info → pulse_framework-0.1.64.dist-info}/RECORD

@@ -1,10 +1,10 @@
-pulse/__init__.py,sha256=_7WUYtxNI78XXdnVu0CFTxRInlCEaP1tGEf-WXMU48I,31993
+pulse/__init__.py,sha256=hf1FFA4EDRxFNiPQoKwQfNHtnCf4UT7STqzgbjJ7dgI,32043
 pulse/_examples.py,sha256=dFuhD2EVXsbvAeexoG57s4VuN4gWLaTMOEMNYvlPm9A,561
 pulse/app.py,sha256=KnP6U8uHgfBbFMguDcVk0KgjakY1UC1NJk2rS5l6Sas,35145
 pulse/channel.py,sha256=sQrDLh3k9Z8CyJQkEHzKu4h-yR4XSTgAA3OCQax3Ciw,15766
 pulse/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pulse/cli/cmd.py,sha256=zh3Ah6c16cNg3o_v_If_S58Qe8rvxNe5M2VrTkwvDU8,15957
-pulse/cli/dependencies.py,sha256=ezFw-7YWnJcvB1k25b0nB_OaOaP-EKtleNtBE2oJUUk,4603
+pulse/cli/dependencies.py,sha256=qU-rF7QyP0Rl1Fl0YKQubrGNBzj84BAbH1uUT3ehxik,4283
 pulse/cli/folder_lock.py,sha256=-AKld2iM91G0uHB3F5ARD0QAjOw0TmsYYGaFgy_V350,3477
 pulse/cli/helpers.py,sha256=XXRRXeGFgeq-jbp0QGFFVq_aGg_Kp7_AkYsTK8LfSdg,7810
 pulse/cli/logging.py,sha256=3uuB1dqI-lHJkodNUURN6UMWdKF5UQ9spNG-hBG7bA4,2516
@@ -21,7 +21,7 @@ pulse/codegen/templates/layout.py,sha256=nmWPQcO9SRXc3mCCVLCmykreSF96TqQfdDY7dvU
 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
-pulse/component.py,sha256=TVgV0dgNDf2Smt2xsJVD0-Wejsnqm14n-NxBzsdObjc,6227
+pulse/component.py,sha256=mY4ZTX7XKXGXAiVwTec1YR3_HOJf6uTdZcxCT_WX5Gs,6230
 pulse/components/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pulse/components/for_.py,sha256=lrt1JHegf4OkBbL9nrMOy7zxmbuD8Kn11x32ZGS72lY,2390
 pulse/components/if_.py,sha256=5IOq3R70B-JdI-fvDNYDyAaSEtO8L5OaiqHp-jUn-Kw,2153
@@ -80,10 +80,10 @@ pulse/queries/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pulse/queries/client.py,sha256=AW42ZPdZJfDkCERpoxQnsiU5cYLfOlZX0sIb9BdIL4E,18495
 pulse/queries/common.py,sha256=TYhn6LyldfmOKYYurxINgCEr3C3WSEwB0cIki1a5iBM,2488
 pulse/queries/effect.py,sha256=7KvV_yK7OHTWhfQbZFGzg_pRhyI2mn25pKIF9AmSmcU,1471
-pulse/queries/infinite_query.py,sha256=oPZq_TEVPHTdMy6-XfjN0hGFy_uhU14vdtn-UsCUHBQ,45764
+pulse/queries/infinite_query.py,sha256=3_gv_pDTShNDf_y2yQ-QLDskJOxXhg1dOmQbU2_QxhE,48101
 pulse/queries/mutation.py,sha256=fhEpOZ7CuHImH4Y02QapYdTJrwe6K52-keb0d67wmms,8274
-pulse/queries/protocol.py,sha256=R8n238Ex9DbYIAVKB83a8FAPtnCiPNhWar-F01K2fTo,3345
-pulse/queries/query.py,sha256=GTZY6xvan4mC3GgLbkRnzo6lSvfRhriN2UznyjyiEWE,38682
+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/react_component.py,sha256=8RLg4Bi7IcjqbnbEnp4hJpy8t1UsE7mG0UR1Q655LDk,2332
 pulse/reactive.py,sha256=FxxpH7NBtQr7G89iCVN7y1EG21f23GcRi1M-XIxcRQA,31280
@@ -91,6 +91,7 @@ pulse/reactive_extensions.py,sha256=yQ1PpdAh4kMvll7R15T72FOg8NFdG_HGBsGc63dawYk,
 pulse/render_session.py,sha256=9gfwuBZRCWuQMN_nFuaAi__1UPN3I3C1mKWtAXyA3-A,21340
 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/serializer.py,sha256=HmQZgxQiaCx2SL2XwmEQLd_xsk_P8XfLtGciLLLOxx0,7616
 pulse/state.py,sha256=VMphVpYNU1CyHMMg1_kNJO3cfqLXJPAuq9gr9RYyUAw,15922
@@ -103,7 +104,7 @@ pulse/transpiler/emit_context.py,sha256=GyK6VdsBSTVIewQRhBagaV0hlqLTlPZ1i8EAZGi8
 pulse/transpiler/errors.py,sha256=LSBjLBnMglbl2D94p9JR4y-3jDefk6iHSlUVBaBOTu4,2823
 pulse/transpiler/function.py,sha256=a871LZFergCmjs1vr-XlOx4eU1FQKAuYxSLJej-LHHc,17036
 pulse/transpiler/id.py,sha256=CdgA1NndBpZjv0Hp4XiYbKn7wi-x4zWsFSjEiViKxVk,434
-pulse/transpiler/imports.py,sha256=RWw5HJXWwQKRCOoNCMtfBA_CQMBte5XfVTmYqXdQuaA,9702
+pulse/transpiler/imports.py,sha256=gWLjRr9jakbUzBGDEepE2RI5Xn_UZwOD4TmlqjNIapM,10302
 pulse/transpiler/js_module.py,sha256=OcIgmrfiA6Hh6aukzgkyX63KsVSHdLzx5ezdKiJFUaQ,11093
 pulse/transpiler/modules/__init__.py,sha256=JGi3CuZoF4sug4dNhQg3MFhpEQqnXec4xRJM2cHNP3c,1184
 pulse/transpiler/modules/asyncio.py,sha256=kWMuFU2vZbqutCM_EXJMvy5SdlB66XiT0czs8lELj_o,1584
@@ -112,7 +113,7 @@ pulse/transpiler/modules/math.py,sha256=8gjvdYTMqtuOnXrvX_Lwuo0ywAdSl7cpss4TMk6m
 pulse/transpiler/modules/pulse/__init__.py,sha256=TfMsiiB53ZFlxdNl7jfCAiMZs-vSRUTxUmqzkLTj-po,91
 pulse/transpiler/modules/pulse/tags.py,sha256=FMN1mWMlnsXa2qO6VmXxUAhFn1uOfGoKPQOjH4ZPlRE,6218
 pulse/transpiler/modules/typing.py,sha256=J9QCkXE6zzwMjiprX2q1BtK-iKLIiS21sQ78JH4RSMc,1716
-pulse/transpiler/nodes.py,sha256=oiAoHZ-q7zmp3zenvVr1aDesyd3nPmC8Uxgm5KG7qeM,50474
+pulse/transpiler/nodes.py,sha256=xJSUb0PfqyfvG85ZnUwZMzUs4JVeCJTw87biI2K2UC8,51742
 pulse/transpiler/py_module.py,sha256=um4BYLrbs01bpgv2LEBHTbhXXh8Bs174c3ygv5tHHOg,4410
 pulse/transpiler/transpiler.py,sha256=28diEp1yZTs3RsUEJZZdCv1DfzgO9WyOGI-xSHe7y_4,32562
 pulse/transpiler/vdom.py,sha256=Ie36iHa2bkUbui5iMClbMSFDGlKaNxI98Ux0JLPCGT4,6399
@@ -120,7 +121,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.62.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
-pulse_framework-0.1.62.dist-info/entry_points.txt,sha256=i7aohd3QaPu5IcuGKKvsQQEiMYMe5HcF56QEsaLVO64,46
-pulse_framework-0.1.62.dist-info/METADATA,sha256=Vs73aVk7hGZuZcVSnMmuJC6BY-rMUpTXTtc6UkRsWN0,8300
-pulse_framework-0.1.62.dist-info/RECORD,,
+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,,