pulse-framework 0.1.73__py3-none-any.whl → 0.1.74__py3-none-any.whl

pulse/transpiler/__init__.py

@@ -106,6 +106,11 @@ from pulse.transpiler.nodes import While as While
 # Emit
 from pulse.transpiler.nodes import emit as emit
 
+# Parse helpers
+from pulse.transpiler.parse import ParsedSource as ParsedSource
+from pulse.transpiler.parse import get_ast as get_ast
+from pulse.transpiler.parse import get_source as get_source
+
 # Transpiler
 from pulse.transpiler.transpiler import Transpiler as Transpiler
 from pulse.transpiler.transpiler import transpile as transpile

pulse/transpiler/function.py

@@ -7,8 +7,8 @@ and JsFunction which wraps transpiled functions with their dependencies.
 from __future__ import annotations
 
 import ast
+import dis
 import inspect
-import textwrap
 import types as pytypes
 from collections.abc import Callable
 from dataclasses import dataclass, field
@@ -25,7 +25,6 @@ from typing import (
 	override,
 )
 
-from pulse.helpers import getsourcecode
 from pulse.transpiler.errors import TranspileError
 from pulse.transpiler.id import next_id, reset_id_counter
 from pulse.transpiler.imports import Import
@@ -38,6 +37,7 @@ from pulse.transpiler.nodes import (
 	Return,
 	to_js_identifier,
 )
+from pulse.transpiler.parse import clear_parse_cache, get_ast, get_source
 from pulse.transpiler.transpiler import Transpiler
 from pulse.transpiler.vdom import VDOMExpr
 
@@ -63,6 +63,7 @@ def clear_function_cache() -> None:
 
 	FUNCTION_CACHE.clear()
 	CONSTANT_REGISTRY.clear()
+	clear_parse_cache()
 	clear_import_registry()
 	clear_asset_registry()
 	reset_id_counter()
@@ -137,33 +138,17 @@ def _transpile_function_body(
 	deps: dict[str, Expr],
 	*,
 	jsx: bool = False,
-) -> tuple[Function | Arrow, str]:
+) -> Function | Arrow:
 	"""Shared transpilation logic for JsFunction and JsxFunction.
 
-	Returns the transpiled Function/Arrow node and the source code.
+	Returns the transpiled Function/Arrow node.
 	"""
 	# Get and parse source
-	src = getsourcecode(fn)
-	src = textwrap.dedent(src)
-	try:
-		source_start_line = inspect.getsourcelines(fn)[1]
-	except (OSError, TypeError):
-		source_start_line = None
-	module = ast.parse(src)
-
-	# Find the function definition
-	fndefs = [
-		n for n in module.body if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))
-	]
-	if not fndefs:
-		raise TranspileError("No function definition found in source")
-	fndef = fndefs[-1]
-
-	# Get filename for error messages and source file resolution
-	try:
-		filename = inspect.getfile(fn)
-	except (TypeError, OSError):
-		filename = None
+	parsed = get_source(fn)
+	src = parsed.source
+	fndef = get_ast(fn)
+	filename = parsed.filename
+	source_start_line = parsed.source_start_line
 
 	# Transpile with source context for errors
 	try:
@@ -181,7 +166,7 @@ def _transpile_function_body(
 			) from None
 		raise
 
-	return result, src
+	return result
 
 
 @dataclass(slots=True, init=False)
@@ -238,7 +223,7 @@ class JsFunction(Expr, Generic[*Args, R]):
 		if self._transpiled is not None:
 			return self._transpiled
 
-		result, _ = _transpile_function_body(self.fn, self.deps)
+		result = _transpile_function_body(self.fn, self.deps)
 
 		# Convert Arrow to Function if needed, and set the name
 		if isinstance(result, Function):
@@ -326,7 +311,7 @@ class JsxFunction(Expr, Generic[P, R]):
 		if self._transpiled is not None:
 			return self._transpiled
 
-		result, _ = _transpile_function_body(self.fn, self.deps, jsx=True)
+		result = _transpile_function_body(self.fn, self.deps, jsx=True)
 
 		# JSX transpilation always returns Function (never Arrow)
 		assert isinstance(result, Function), (
@@ -376,7 +361,6 @@ def analyze_code_object(
 	    - effective_globals: dict mapping names to their values (includes closure vars)
 	    - all_names: set of all names referenced in the code (including nested functions)
 	"""
-	import dis
 
 	code = fn.__code__
 
@@ -443,14 +427,54 @@ def analyze_deps(fn: Callable[..., Any]) -> dict[str, Expr]:
 	"""
 	# Analyze code object and resolve globals + closure vars
 	effective_globals, all_names = analyze_code_object(fn)
+	code_names = set(all_names)
+	default_names: set[str] = set()
+	default_name_values: dict[str, Any] = {}
+
+	# Include names referenced only in default expressions (not in bytecode)
+	try:
+		args = get_ast(fn).args
+		pos_defaults = list(args.defaults)
+		py_defaults = fn.__defaults__ or ()
+		num_args = len(args.args)
+		num_defaults = len(pos_defaults)
+		for i, _arg in enumerate(args.args):
+			default_idx = i - (num_args - num_defaults)
+			if default_idx < 0 or default_idx >= len(pos_defaults):
+				continue
+			default_node = pos_defaults[default_idx]
+			if isinstance(default_node, ast.Name) and default_idx < len(py_defaults):
+				default_name_values[default_node.id] = py_defaults[default_idx]
+			for node in ast.walk(default_node):
+				if isinstance(node, ast.Name):
+					default_names.add(node.id)
+
+		py_kwdefaults = fn.__kwdefaults__ or {}
+		for i, kwarg in enumerate(args.kwonlyargs):
+			default_node = args.kw_defaults[i]
+			if default_node is None:
+				continue
+			if isinstance(default_node, ast.Name) and kwarg.arg in py_kwdefaults:
+				default_name_values[default_node.id] = py_kwdefaults[kwarg.arg]
+			for node in ast.walk(default_node):
+				if isinstance(node, ast.Name):
+					default_names.add(node.id)
+	except (OSError, TypeError, SyntaxError, TranspileError):
+		pass
+
+	all_names.update(default_names)
+	default_only_names = default_names - code_names
 
 	# Build dependencies dictionary - all values are Expr
 	deps: dict[str, Expr] = {}
 
+	missing = object()
 	for name in all_names:
-		value = effective_globals.get(name)
-
-		if value is None:
+		if name in default_only_names and name in default_name_values:
+			value = default_name_values[name]
+		else:
+			value = effective_globals.get(name, missing)
+		if value is missing:
 			# Not in globals - could be a builtin or unresolved
 			# For now, skip - builtins will be handled by the transpiler
 			# TODO: Add builtin support

pulse/transpiler/nodes.py

@@ -1517,7 +1517,7 @@ class If(Stmt):
 
 @dataclass(slots=True)
 class ForOf(Stmt):
-	"""JS for-of loop: for (const x of iter) { ... }
+	"""JS for-of loop: for (x of iter) { ... }
 
 	target can be a single name or array pattern for destructuring: [a, b]
 	"""
@@ -1528,7 +1528,7 @@ class ForOf(Stmt):
 
 	@override
 	def emit(self, out: list[str]) -> None:
-		out.append("for (const ")
+		out.append("for (")
 		out.append(self.target)
 		out.append(" of ")
 		self.iter.emit(out)
@@ -1619,6 +1619,21 @@ class Assign(Stmt):
 		out.append(";")
 
 
+@dataclass(slots=True)
+class LetDecl(Stmt):
+	"""JS let declaration: let a, b;"""
+
+	names: Sequence[str]
+
+	@override
+	def emit(self, out: list[str]) -> None:
+		if not self.names:
+			return
+		out.append("let ")
+		out.append(", ".join(self.names))
+		out.append(";")
+
+
 @dataclass(slots=True)
 class ExprStmt(Stmt):
 	"""JS expression statement: expr;"""

pulse/transpiler/parse.py

@@ -0,0 +1,70 @@
+"""Cached parsing helpers for transpiler source inspection."""
+
+from __future__ import annotations
+
+import ast
+import inspect
+import textwrap
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+from pulse.helpers import getsourcecode
+from pulse.transpiler.errors import TranspileError
+
+
+@dataclass(slots=True)
+class ParsedSource:
+	source: str
+	filename: str | None
+	source_start_line: int | None
+
+
+_SOURCE_CACHE: dict[Callable[..., Any], ParsedSource] = {}
+_AST_CACHE: dict[Callable[..., Any], ast.FunctionDef | ast.AsyncFunctionDef] = {}
+
+
+def clear_parse_cache() -> None:
+	_SOURCE_CACHE.clear()
+	_AST_CACHE.clear()
+
+
+def get_source(fn: Callable[..., Any]) -> ParsedSource:
+	cached = _SOURCE_CACHE.get(fn)
+	if cached is not None:
+		return cached
+
+	src = getsourcecode(fn)
+	src = textwrap.dedent(src)
+	try:
+		source_start_line = inspect.getsourcelines(fn)[1]
+	except (OSError, TypeError):
+		source_start_line = None
+	try:
+		filename = inspect.getfile(fn)
+	except (TypeError, OSError):
+		filename = None
+
+	parsed = ParsedSource(
+		source=src,
+		filename=filename,
+		source_start_line=source_start_line,
+	)
+	_SOURCE_CACHE[fn] = parsed
+	return parsed
+
+
+def get_ast(fn: Callable[..., Any]) -> ast.FunctionDef | ast.AsyncFunctionDef:
+	cached = _AST_CACHE.get(fn)
+	if cached is not None:
+		return cached
+
+	module = ast.parse(get_source(fn).source)
+	fndefs = [
+		n for n in module.body if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))
+	]
+	if not fndefs:
+		raise TranspileError("No function definition found in source")
+	fndef = fndefs[-1]
+	_AST_CACHE[fn] = fndef
+	return fndef

pulse/transpiler/transpiler.py

@@ -10,8 +10,9 @@ from __future__ import annotations
 import ast
 import re
 from collections.abc import Callable, Mapping
+from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, cast
+from typing import Any, cast, override
 
 from pulse.transpiler.builtins import BUILTINS, emit_method
 from pulse.transpiler.errors import TranspileError
@@ -30,6 +31,7 @@ from pulse.transpiler.nodes import (
 	Function,
 	Identifier,
 	If,
+	LetDecl,
 	Literal,
 	Member,
 	New,
@@ -78,6 +80,228 @@ ALLOWED_CMPOPS: dict[type[ast.cmpop], str] = {
 }
 
 
+def _collect_param_names(args: ast.arguments) -> list[str]:
+	"""Collect argument names (regular, vararg, kwonly, kwarg)."""
+	names: list[str] = [arg.arg for arg in args.args]
+	if args.vararg:
+		names.append(args.vararg.arg)
+	names.extend(arg.arg for arg in args.kwonlyargs)
+	if args.kwarg:
+		names.append(args.kwarg.arg)
+	return names
+
+
+@dataclass(slots=True)
+class Scope:
+	locals: set[str]
+	params: set[str]
+	parent: "Scope | None" = None
+
+
+class ScopeAnalyzer(ast.NodeVisitor):
+	"""Collect locals per scope (function/lambda/comprehension)."""
+
+	_scopes: dict[ast.AST, Scope]
+	_stack: list[Scope]
+	_global_scope: Scope
+
+	def __init__(self) -> None:
+		self._scopes = {}
+		self._stack = []
+		self._global_scope = Scope(locals=set(), params=set(), parent=None)
+
+	def analyze(
+		self, node: ast.FunctionDef | ast.AsyncFunctionDef
+	) -> dict[ast.AST, Scope]:
+		self._stack.append(self._global_scope)
+		self._visit_defaults(node.args)
+		scope = self._new_scope(
+			node, _collect_param_names(node.args), parent=self._global_scope
+		)
+		self._stack.append(scope)
+		for stmt in node.body:
+			self.visit(stmt)
+		self._stack.pop()
+		self._stack.pop()
+		return self._scopes
+
+	def _new_scope(
+		self,
+		node: ast.AST,
+		params: list[str],
+		*,
+		parent: Scope | None,
+	) -> Scope:
+		param_set = set(params)
+		scope = Scope(locals=set(param_set), params=param_set, parent=parent)
+		self._scopes[node] = scope
+		return scope
+
+	def _current_scope(self) -> Scope:
+		return self._stack[-1]
+
+	def _add_local(self, name: str) -> None:
+		self._current_scope().locals.add(name)
+
+	def _add_targets(self, target: ast.expr) -> None:
+		if isinstance(target, ast.Name):
+			self._add_local(target.id)
+			return
+		if isinstance(target, (ast.Tuple, ast.List)):
+			for elt in target.elts:
+				if isinstance(elt, ast.Name):
+					self._add_local(elt.id)
+
+	def _visit_target_expr(self, target: ast.expr) -> None:
+		if isinstance(target, (ast.Tuple, ast.List)):
+			for elt in target.elts:
+				self._visit_target_expr(elt)
+			return
+		self.visit(target)
+
+	def _analyze_function(self, node: ast.FunctionDef | ast.AsyncFunctionDef) -> None:
+		self._visit_defaults(node.args)
+		scope = self._new_scope(
+			node,
+			_collect_param_names(node.args),
+			parent=self._current_scope(),
+		)
+		self._stack.append(scope)
+		for stmt in node.body:
+			self.visit(stmt)
+		self._stack.pop()
+
+	@property
+	def global_scope(self) -> Scope:
+		return self._global_scope
+
+	def _visit_defaults(self, args: ast.arguments) -> None:
+		for default in args.defaults:
+			self.visit(default)
+		for default in args.kw_defaults:
+			if default is not None:
+				self.visit(default)
+
+	@override
+	def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
+		self._add_local(node.name)
+		self._analyze_function(node)
+
+	@override
+	def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> None:
+		self._add_local(node.name)
+		self._analyze_function(node)
+
+	@override
+	def visit_Lambda(self, node: ast.Lambda) -> None:
+		scope = self._new_scope(
+			node,
+			_collect_param_names(node.args),
+			parent=self._current_scope(),
+		)
+		self._stack.append(scope)
+		self.visit(node.body)
+		self._stack.pop()
+
+	def _visit_comprehension(
+		self,
+		node: ast.ListComp | ast.SetComp | ast.DictComp | ast.GeneratorExp,
+		*,
+		elt: ast.expr,
+		key: ast.expr | None = None,
+	) -> None:
+		scope = self._new_scope(node, [], parent=self._current_scope())
+		self._stack.append(scope)
+		if key is not None:
+			self.visit(key)
+		self.visit(elt)
+		for gen in node.generators:
+			self.visit(gen.iter)
+			for if_node in gen.ifs:
+				self.visit(if_node)
+		self._stack.pop()
+
+	@override
+	def visit_ListComp(self, node: ast.ListComp) -> None:
+		self._visit_comprehension(node, elt=node.elt)
+
+	@override
+	def visit_SetComp(self, node: ast.SetComp) -> None:
+		self._visit_comprehension(node, elt=node.elt)
+
+	@override
+	def visit_GeneratorExp(self, node: ast.GeneratorExp) -> None:
+		self._visit_comprehension(node, elt=node.elt)
+
+	@override
+	def visit_DictComp(self, node: ast.DictComp) -> None:
+		self._visit_comprehension(node, elt=node.value, key=node.key)
+
+	@override
+	def visit_Assign(self, node: ast.Assign) -> None:
+		for target in node.targets:
+			if isinstance(target, (ast.Name, ast.Tuple, ast.List)):
+				self._add_targets(target)
+			self._visit_target_expr(target)
+		self.visit(node.value)
+
+	@override
+	def visit_AnnAssign(self, node: ast.AnnAssign) -> None:
+		if isinstance(node.target, (ast.Name, ast.Tuple, ast.List)):
+			self._add_targets(node.target)
+		self._visit_target_expr(node.target)
+		if node.value is not None:
+			self.visit(node.value)
+
+	@override
+	def visit_AugAssign(self, node: ast.AugAssign) -> None:
+		if isinstance(node.target, (ast.Name, ast.Tuple, ast.List)):
+			self._add_targets(node.target)
+		self._visit_target_expr(node.target)
+		self.visit(node.value)
+
+	@override
+	def visit_For(self, node: ast.For) -> None:
+		if isinstance(node.target, (ast.Name, ast.Tuple, ast.List)):
+			self._add_targets(node.target)
+		self._visit_target_expr(node.target)
+		self.visit(node.iter)
+		for stmt in node.body:
+			self.visit(stmt)
+		for stmt in node.orelse:
+			self.visit(stmt)
+
+	@override
+	def visit_ExceptHandler(self, node: ast.ExceptHandler) -> None:
+		if node.name:
+			self._add_local(node.name)
+		if node.type is not None:
+			self.visit(node.type)
+		for stmt in node.body:
+			self.visit(stmt)
+
+	@override
+	def visit_With(self, node: ast.With) -> None:
+		for item in node.items:
+			if item.optional_vars and isinstance(
+				item.optional_vars, (ast.Name, ast.Tuple, ast.List)
+			):
+				self._add_targets(item.optional_vars)
+			if item.optional_vars is not None:
+				self._visit_target_expr(item.optional_vars)
+			self.visit(item.context_expr)
+		for stmt in node.body:
+			self.visit(stmt)
+
+	@override
+	def visit_Global(self, node: ast.Global) -> None:
+		raise TranspileError("global is not supported", node=node)
+
+	@override
+	def visit_Nonlocal(self, node: ast.Nonlocal) -> None:
+		raise TranspileError("nonlocal is not supported", node=node)
+
+
 class Transpiler:
 	"""Transpile Python AST to v2 Expr/Stmt AST nodes.
 
@@ -93,10 +317,12 @@ class Transpiler:
 	fndef: ast.FunctionDef | ast.AsyncFunctionDef
 	args: list[str]
 	deps: Mapping[str, Expr]
-	locals: set[str]
 	jsx: bool
 	source_file: Path | None
 	_temp_counter: int
+	_scope_map: dict[ast.AST, Scope]
+	_scope_stack: list[Scope]
+	_global_scope: Scope
 
 	def __init__(
 		self,
@@ -109,22 +335,21 @@ class Transpiler:
 		self.fndef = fndef
 		self.source_file = source_file
 		# Collect all argument names (regular, vararg, kwonly, kwarg)
-		args: list[str] = [arg.arg for arg in fndef.args.args]
-		if fndef.args.vararg:
-			args.append(fndef.args.vararg.arg)
-		args.extend(arg.arg for arg in fndef.args.kwonlyargs)
-		if fndef.args.kwarg:
-			args.append(fndef.args.kwarg.arg)
-		self.args = args
+		self.args = _collect_param_names(fndef.args)
 		self.deps = deps
 		self.jsx = jsx
-		self.locals = set(self.args)
 		self._temp_counter = 0
+		analyzer = ScopeAnalyzer()
+		self._scope_map = analyzer.analyze(fndef)
+		self._global_scope = analyzer.global_scope
+		self._scope_stack = [self._scope_map[fndef]]
 		self.init_temp_counter()
 
 	def init_temp_counter(self) -> None:
 		"""Initialize temp counter to avoid collisions with args or globals."""
-		all_names = set(self.args) | set(self.deps.keys())
+		all_names = set(self.deps.keys())
+		for scope in self._scope_map.values():
+			all_names.update(scope.locals)
 		counter = 0
 		while f"$tmp{counter}" in all_names:
 			counter += 1
@@ -136,6 +361,38 @@ class Transpiler:
 		self._temp_counter += 1
 		return name
 
+	def _current_scope(self) -> Scope:
+		return self._scope_stack[-1]
+
+	def _push_scope(self, node: ast.AST) -> None:
+		self._scope_stack.append(self._scope_map[node])
+
+	def _pop_scope(self) -> None:
+		self._scope_stack.pop()
+
+	def _is_local_here(self, name: str) -> bool:
+		return name in self._current_scope().locals
+
+	def _is_local(self, name: str) -> bool:
+		scope: Scope | None = self._current_scope()
+		while scope is not None:
+			if name in scope.locals:
+				return True
+			scope = scope.parent
+		return False
+
+	def _require_local(
+		self, name: str, *, node: ast.expr | ast.stmt | ast.excepthandler
+	) -> None:
+		if not self._is_local_here(name):
+			raise TranspileError(f"Assignment to unknown local: {name}", node=node)
+
+	def _function_prelude(self, scope: Scope) -> list[Stmt]:
+		names = sorted(scope.locals - scope.params)
+		if not names:
+			return []
+		return [LetDecl(names)]
+
 	# --- Entrypoint ---------------------------------------------------------
 
 	def transpile(self) -> Function | Arrow:
@@ -176,7 +433,8 @@ class Transpiler:
 					return Arrow(self.args, expr)
 
 		# General case: Function (for JSX or multi-statement)
-		stmts = [self.emit_stmt(s) for s in body]
+		prelude = self._function_prelude(self._current_scope())
+		stmts = prelude + [self.emit_stmt(s) for s in body]
 		is_async = isinstance(self.fndef, ast.AsyncFunctionDef)
 		args = [self._jsx_args()] if self.jsx else self.args
 		return Function(args, stmts, is_async=is_async)
@@ -202,7 +460,7 @@ class Transpiler:
 			if default_idx >= 0:
 				# Has a default value
 				default_node = args.defaults[default_idx]
-				default_expr = self.emit_expr(default_node)
+				default_expr = self._emit_default_expr(default_node)
 				default_out.clear()
 				default_expr.emit(default_out)
 				destructure_parts.append(f"{param_name} = {''.join(default_out)}")
@@ -220,7 +478,7 @@ class Transpiler:
 			default_node = args.kw_defaults[i]
 			if default_node is not None:
 				# Has a default value
-				default_expr = self.emit_expr(default_node)
+				default_expr = self._emit_default_expr(default_node)
 				default_out.clear()
 				default_expr.emit(default_out)
 				destructure_parts.append(f"{param_name} = {''.join(default_out)}")
@@ -234,6 +492,14 @@ class Transpiler:
 
 		return "{" + ", ".join(destructure_parts) + "}"
 
+	def _emit_default_expr(self, node: ast.expr) -> Expr:
+		"""Emit defaults in defining-scope context."""
+		self._scope_stack.append(self._global_scope)
+		try:
+			return self.emit_expr(node)
+		finally:
+			self._scope_stack.pop()
+
 	# --- Statements ----------------------------------------------------------
 
 	def emit_stmt(self, node: ast.stmt) -> Stmt:
@@ -262,6 +528,7 @@ class Transpiler:
 					"Only simple augmented assignments supported", node=node
 				)
 			target = node.target.id
+			self._require_local(target, node=node)
 			op_type = type(node.op)
 			if op_type not in ALLOWED_BINOPS:
 				raise TranspileError(
@@ -296,22 +563,16 @@ class Transpiler:
 			target = target_node.id
 			value_expr = self.emit_expr(node.value)
 
-			if target in self.locals:
-				return Assign(target, value_expr)
-			else:
-				self.locals.add(target)
-				return Assign(target, value_expr, declare="let")
+			self._require_local(target, node=node)
+			return Assign(target, value_expr)
 
 		if isinstance(node, ast.AnnAssign):
 			if not isinstance(node.target, ast.Name):
 				raise TranspileError("Only simple annotated assignments supported")
 			target = node.target.id
 			value = Literal(None) if node.value is None else self.emit_expr(node.value)
-			if target in self.locals:
-				return Assign(target, value)
-			else:
-				self.locals.add(target)
-				return Assign(target, value, declare="let")
+			self._require_local(target, node=node)
+			return Assign(target, value)
 
 		if isinstance(node, ast.If):
 			cond = self.emit_expr(node.test)
@@ -358,11 +619,8 @@ class Transpiler:
 			assert isinstance(e, ast.Name)
 			name = e.id
 			sub = Subscript(Identifier(tmp_name), Literal(idx))
-			if name in self.locals:
-				stmts.append(Assign(name, sub))
-			else:
-				self.locals.add(name)
-				stmts.append(Assign(name, sub, declare="let"))
+			self._require_local(name, node=target)
+			stmts.append(Assign(name, sub))
 
 		return StmtSequence(stmts)
 
@@ -453,7 +711,7 @@ class Transpiler:
 						"Only simple name targets supported in for-loop unpacking"
 					)
 				names.append(e.id)
-				self.locals.add(e.id)
+				self._require_local(e.id, node=node)
 			iter_expr = self.emit_expr(node.iter)
 			body = [self.emit_stmt(s) for s in node.body]
 			# Use array pattern for destructuring
@@ -464,7 +722,7 @@ class Transpiler:
 			raise TranspileError("Only simple name targets supported in for-loops")
 
 		target = node.target.id
-		self.locals.add(target)
+		self._require_local(target, node=node)
 		iter_expr = self.emit_expr(node.iter)
 		body = [self.emit_stmt(s) for s in node.body]
 		return ForOf(target, iter_expr, body)
@@ -474,31 +732,29 @@ class Transpiler:
 	) -> Stmt:
 		"""Emit a nested function definition."""
 		name = node.name
-		params = [arg.arg for arg in node.args.args]
-
-		# Save current locals and extend with params
-		saved_locals = set(self.locals)
-		self.locals.update(params)
-
-		# Skip docstrings and emit body
-		body_stmts = node.body
-		if (
-			body_stmts
-			and isinstance(body_stmts[0], ast.Expr)
-			and isinstance(body_stmts[0].value, ast.Constant)
-			and isinstance(body_stmts[0].value.value, str)
-		):
-			body_stmts = body_stmts[1:]
+		params = _collect_param_names(node.args)
+		self._require_local(name, node=node)
 
-		stmts: list[Stmt] = [self.emit_stmt(s) for s in body_stmts]
+		self._push_scope(node)
+		try:
+			# Skip docstrings and emit body
+			body_stmts = node.body
+			if (
+				body_stmts
+				and isinstance(body_stmts[0], ast.Expr)
+				and isinstance(body_stmts[0].value, ast.Constant)
+				and isinstance(body_stmts[0].value.value, str)
+			):
+				body_stmts = body_stmts[1:]
 
-		# Restore outer locals and add function name
-		self.locals = saved_locals
-		self.locals.add(name)
+			prelude = self._function_prelude(self._current_scope())
+			stmts: list[Stmt] = prelude + [self.emit_stmt(s) for s in body_stmts]
+		finally:
+			self._pop_scope()
 
 		is_async = isinstance(node, ast.AsyncFunctionDef)
 		fn = Function(params, stmts, is_async=is_async)
-		return Assign(name, fn, declare="const")
+		return Assign(name, fn)
 
 	def _emit_try(self, node: ast.Try) -> Stmt:
 		"""Emit a try/except/finally statement."""
@@ -517,7 +773,6 @@ class Transpiler:
 			handler = node.handlers[0]
 			if handler.name:
 				catch_param = handler.name
-				self.locals.add(catch_param)
 			catch_body = [self.emit_stmt(s) for s in handler.body]
 
 		# Handle finally
@@ -594,23 +849,21 @@ class Transpiler:
 
 		if isinstance(node, ast.ListComp):
 			return self._emit_comprehension_chain(
-				node.generators, lambda: self.emit_expr(node.elt)
+				node, lambda: self.emit_expr(node.elt)
 			)
 
 		if isinstance(node, ast.GeneratorExp):
 			return self._emit_comprehension_chain(
-				node.generators, lambda: self.emit_expr(node.elt)
+				node, lambda: self.emit_expr(node.elt)
 			)
 
 		if isinstance(node, ast.SetComp):
-			arr = self._emit_comprehension_chain(
-				node.generators, lambda: self.emit_expr(node.elt)
-			)
+			arr = self._emit_comprehension_chain(node, lambda: self.emit_expr(node.elt))
 			return New(Identifier("Set"), [arr])
 
 		if isinstance(node, ast.DictComp):
 			pairs = self._emit_comprehension_chain(
-				node.generators,
+				node,
 				lambda: Array([self.emit_expr(node.key), self.emit_expr(node.value)]),
 			)
 			return New(Identifier("Map"), [pairs])
@@ -648,14 +901,14 @@ class Transpiler:
 		"""Emit a name reference."""
 		name = node.id
 
-		# Check deps first
+		# Local variable (current or enclosing scope)
+		if self._is_local(name):
+			return Identifier(name)
+
+		# Check deps
 		if name in self.deps:
 			return self.deps[name]
 
-		# Local variable
-		if name in self.locals:
-			return Identifier(name)
-
 		# Check builtins
 		if name in BUILTINS:
 			return BUILTINS[name]
@@ -1093,29 +1346,26 @@ class Transpiler:
 
 	def _emit_lambda(self, node: ast.Lambda) -> Expr:
 		"""Emit a lambda expression as an arrow function."""
-		params = [arg.arg for arg in node.args.args]
-
-		# Add params to locals temporarily
-		saved_locals = set(self.locals)
-		self.locals.update(params)
-
-		body = self.emit_expr(node.body)
+		params = _collect_param_names(node.args)
 
-		self.locals = saved_locals
+		self._push_scope(node)
+		try:
+			body = self.emit_expr(node.body)
+		finally:
+			self._pop_scope()
 
 		return Arrow(params, body)
 
 	def _emit_comprehension_chain(
 		self,
-		generators: list[ast.comprehension],
+		node: ast.ListComp | ast.SetComp | ast.DictComp | ast.GeneratorExp,
 		build_last: Callable[[], Expr],
 	) -> Expr:
 		"""Build a flatMap/map chain for comprehensions."""
+		generators = node.generators
 		if len(generators) == 0:
 			raise TranspileError("Empty comprehension")
 
-		saved_locals = set(self.locals)
-
 		def build_chain(gen_index: int) -> Expr:
 			gen = generators[gen_index]
 			if gen.is_async:
@@ -1139,7 +1389,7 @@ class Transpiler:
 				)
 
 			for nm in names:
-				self.locals.add(nm)
+				self._current_scope().locals.add(nm)
 
 			base = iter_expr
 
@@ -1159,10 +1409,11 @@ class Transpiler:
 			inner = build_chain(gen_index + 1)
 			return Call(Member(base, "flatMap"), [Arrow(params, inner)])
 
+		self._push_scope(node)
 		try:
 			return build_chain(0)
 		finally:
-			self.locals = saved_locals
+			self._pop_scope()
 
 
 def transpile(

{pulse_framework-0.1.73.dist-info → pulse_framework-0.1.74.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pulse-framework
-Version: 0.1.73
+Version: 0.1.74
 Summary: Pulse - Full-stack framework for building real-time React applications in Python
 Requires-Dist: fastapi>=0.128.0
 Requires-Dist: uvicorn>=0.24.0

{pulse_framework-0.1.73.dist-info → pulse_framework-0.1.74.dist-info}/RECORD

@@ -101,13 +101,13 @@ pulse/state/property.py,sha256=pitudvCGBNqK6lePdPrs4Inyy7szo8qcR_0BI30veek,6274
 pulse/state/query_param.py,sha256=7faf244_KJ3yrsBimKTBlNLg6wP96FUuWoZl40oxpyY,14478
 pulse/state/state.py,sha256=_4DcB-og2s5Ui01kDx9HzpNwmAVD_pdCLB0TfYbcnzM,11603
 pulse/test_helpers.py,sha256=4iO5Ymy3SMvSjh-UaAaSdqm1I_SAJMNjdY2iYVro5f8,436
-pulse/transpiler/__init__.py,sha256=wDDnzqxgHpp_OLtcgyrJEg2jVoTnFIe3SSSTOsMDW8w,4700
+pulse/transpiler/__init__.py,sha256=0UqeEQ2dMD2tDDkzTASv-StQfKZkPuSvbYTqjkNk-3A,4895
 pulse/transpiler/assets.py,sha256=digd5hKYPEgLOzMtDBHULX3Adj1sfngdvnx3quQmgPY,2299
 pulse/transpiler/builtins.py,sha256=QZrow7XJ2wxGMAE-mgZmaUD03egOnXCbikOg8yMx9vQ,30807
 pulse/transpiler/dynamic_import.py,sha256=1AmBl6agGSoTZBp_94seXH733fewLOULUix9BOBPtKI,3372
 pulse/transpiler/emit_context.py,sha256=GyK6VdsBSTVIewQRhBagaV0hlqLTlPZ1i8EAZGi8SaY,1321
 pulse/transpiler/errors.py,sha256=LSBjLBnMglbl2D94p9JR4y-3jDefk6iHSlUVBaBOTu4,2823
-pulse/transpiler/function.py,sha256=a871LZFergCmjs1vr-XlOx4eU1FQKAuYxSLJej-LHHc,17036
+pulse/transpiler/function.py,sha256=8-WZC2VcPTGfFeWWQpCltOVPLyr4f1H8pWoCvSnI654,18105
 pulse/transpiler/id.py,sha256=CdgA1NndBpZjv0Hp4XiYbKn7wi-x4zWsFSjEiViKxVk,434
 pulse/transpiler/imports.py,sha256=gWLjRr9jakbUzBGDEepE2RI5Xn_UZwOD4TmlqjNIapM,10302
 pulse/transpiler/js_module.py,sha256=OcIgmrfiA6Hh6aukzgkyX63KsVSHdLzx5ezdKiJFUaQ,11093
@@ -118,15 +118,16 @@ 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=vebA81QXkWoJMygX2CHH_94azKPRATaB6eBs5wdX4rE,52420
+pulse/transpiler/nodes.py,sha256=ObdCFIEvtKMVRO8iy1hIN4L-vC4yPqRvhPS6E344-bE,52673
+pulse/transpiler/parse.py,sha256=uz_KDnjmjzFSjGtVKRznWg95P0NHM8CafWgvqrqJcOs,1622
 pulse/transpiler/py_module.py,sha256=um4BYLrbs01bpgv2LEBHTbhXXh8Bs174c3ygv5tHHOg,4410
-pulse/transpiler/transpiler.py,sha256=pxNFVnJB_zpUnp12cfzeOqUINAb1ZKhlU2E1gYUE6mk,35752
+pulse/transpiler/transpiler.py,sha256=bu33-wGNqHGheT_ZqMnQgEARyPG6xyOvuLuixjxIZnI,42761
 pulse/transpiler/vdom.py,sha256=Bf1yw10hQl8BXa6rhr5byRa5ua3qgRsVGNgEtQneA2A,6460
 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.73.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
-pulse_framework-0.1.73.dist-info/entry_points.txt,sha256=i7aohd3QaPu5IcuGKKvsQQEiMYMe5HcF56QEsaLVO64,46
-pulse_framework-0.1.73.dist-info/METADATA,sha256=PIqxEHW98zMJlT1C_cLNisDzX73GDvGKFW8e4UtVTfk,8299
-pulse_framework-0.1.73.dist-info/RECORD,,
+pulse_framework-0.1.74.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+pulse_framework-0.1.74.dist-info/entry_points.txt,sha256=i7aohd3QaPu5IcuGKKvsQQEiMYMe5HcF56QEsaLVO64,46
+pulse_framework-0.1.74.dist-info/METADATA,sha256=m4TuEvBPlRud4ARyJi26t3nDDk2gFPvFd4xWi8k2w3k,8299
+pulse_framework-0.1.74.dist-info/RECORD,,