pulse-framework 0.1.62__py3-none-any.whl

pulse/transpiler/modules/asyncio.py

@@ -0,0 +1,57 @@
+"""Python asyncio module transpilation to JavaScript Promise operations."""
+
+from __future__ import annotations
+
+from typing import Any, cast, final
+
+from pulse.transpiler.nodes import (
+	Array,
+	Binary,
+	Call,
+	Expr,
+	Identifier,
+	Literal,
+	Member,
+	Ternary,
+)
+from pulse.transpiler.py_module import PyModule
+from pulse.transpiler.transpiler import Transpiler
+
+_Promise = Identifier("Promise")
+
+
+@final
+class PyAsyncio(PyModule):
+	"""Provides transpilation for Python asyncio functions to JavaScript Promise methods."""
+
+	@staticmethod
+	def gather(*coros: Any, return_exceptions: Any = False, ctx: Transpiler) -> Expr:
+		"""Transpile asyncio.gather to Promise.all or Promise.allSettled.
+
+		Args:
+			*coros: Variable number of coroutine/promise expressions
+			return_exceptions: If True, use Promise.allSettled
+			ctx: Transpiler context
+		"""
+		promises = Array([ctx.emit_expr(c) for c in coros])
+		all_call = Call(Member(_Promise, "all"), [promises])
+		all_settled_call = Call(Member(_Promise, "allSettled"), [promises])
+
+		# Optimized: literal True -> allSettled
+		if return_exceptions is True or (
+			isinstance(return_exceptions, Literal) and return_exceptions.value is True
+		):
+			return all_settled_call
+
+		# Optimized: literal False or default -> all
+		if return_exceptions is False or (
+			isinstance(return_exceptions, Literal) and return_exceptions.value is False
+		):
+			return all_call
+
+		# General case: emit ternary on the expression
+		return Ternary(
+			Binary(ctx.emit_expr(cast(Any, return_exceptions)), "===", Literal(True)),
+			all_settled_call,
+			all_call,
+		)

pulse/transpiler/modules/json.py

@@ -0,0 +1,24 @@
+"""Python json module transpilation to JavaScript JSON."""
+
+from __future__ import annotations
+
+from typing import Any, final
+
+from pulse.transpiler.nodes import Call, Expr, Identifier, Member
+from pulse.transpiler.py_module import PyModule
+from pulse.transpiler.transpiler import Transpiler
+
+_JSON = Identifier("JSON")
+
+
+@final
+class PyJson(PyModule):
+	"""Provides transpilation for Python json functions to JavaScript."""
+
+	@staticmethod
+	def dumps(obj: Any, *, ctx: Transpiler) -> Expr:
+		return Call(Member(_JSON, "stringify"), [ctx.emit_expr(obj)])
+
+	@staticmethod
+	def loads(s: Any, *, ctx: Transpiler) -> Expr:
+		return Call(Member(_JSON, "parse"), [ctx.emit_expr(s)])

pulse/transpiler/modules/math.py

@@ -0,0 +1,265 @@
+"""Python math module transpilation to JavaScript Math.
+
+Provides transpilation from Python's `math` module to JavaScript's `Math` object.
+"""
+
+from __future__ import annotations
+
+from typing import Any, final
+
+from pulse.transpiler.nodes import (
+	Binary,
+	Call,
+	Expr,
+	Identifier,
+	Literal,
+	Member,
+	Unary,
+)
+from pulse.transpiler.py_module import PyModule
+from pulse.transpiler.transpiler import Transpiler
+
+# Helpers for building Math.* calls
+_Math = Identifier("Math")
+_Number = Identifier("Number")
+
+
+def _math_prop(name: str) -> Expr:
+	return Member(_Math, name)
+
+
+def _math_call(name: str, args: list[Expr]) -> Expr:
+	return Call(Member(_Math, name), args)
+
+
+def _number_call(name: str, args: list[Expr]) -> Expr:
+	return Call(Member(_Number, name), args)
+
+
+@final
+class PyMath(PyModule):
+	"""Provides transpilation for Python math functions to JavaScript."""
+
+	# Constants
+	pi = _math_prop("PI")
+	e = _math_prop("E")
+	tau = Binary(Literal(2), "*", _math_prop("PI"))
+	inf = Identifier("Infinity")
+	nan = Identifier("NaN")
+
+	# Basic functions
+	@staticmethod
+	def acos(x: Any, *, ctx: Transpiler) -> Expr:
+		return _math_call("acos", [ctx.emit_expr(x)])
+
+	@staticmethod
+	def acosh(x: Any, *, ctx: Transpiler) -> Expr:
+		return _math_call("acosh", [ctx.emit_expr(x)])
+
+	@staticmethod
+	def asin(x: Any, *, ctx: Transpiler) -> Expr:
+		return _math_call("asin", [ctx.emit_expr(x)])
+
+	@staticmethod
+	def asinh(x: Any, *, ctx: Transpiler) -> Expr:
+		return _math_call("asinh", [ctx.emit_expr(x)])
+
+	@staticmethod
+	def atan(x: Any, *, ctx: Transpiler) -> Expr:
+		return _math_call("atan", [ctx.emit_expr(x)])
+
+	@staticmethod
+	def atan2(y: Any, x: Any, *, ctx: Transpiler) -> Expr:
+		return _math_call("atan2", [ctx.emit_expr(y), ctx.emit_expr(x)])
+
+	@staticmethod
+	def atanh(x: Any, *, ctx: Transpiler) -> Expr:
+		return _math_call("atanh", [ctx.emit_expr(x)])
+
+	@staticmethod
+	def cbrt(x: Any, *, ctx: Transpiler) -> Expr:
+		return _math_call("cbrt", [ctx.emit_expr(x)])
+
+	@staticmethod
+	def ceil(x: Any, *, ctx: Transpiler) -> Expr:
+		return _math_call("ceil", [ctx.emit_expr(x)])
+
+	@staticmethod
+	def copysign(x: Any, y: Any, *, ctx: Transpiler) -> Expr:
+		# Math.sign(y) * Math.abs(x)
+		return Binary(
+			_math_call("sign", [ctx.emit_expr(y)]),
+			"*",
+			_math_call("abs", [ctx.emit_expr(x)]),
+		)
+
+	@staticmethod
+	def cos(x: Any, *, ctx: Transpiler) -> Expr:
+		return _math_call("cos", [ctx.emit_expr(x)])
+
+	@staticmethod
+	def cosh(x: Any, *, ctx: Transpiler) -> Expr:
+		return _math_call("cosh", [ctx.emit_expr(x)])
+
+	@staticmethod
+	def degrees(x: Any, *, ctx: Transpiler) -> Expr:
+		# x * (180 / PI)
+		return Binary(
+			ctx.emit_expr(x),
+			"*",
+			Binary(Literal(180), "/", _math_prop("PI")),
+		)
+
+	@staticmethod
+	def exp(x: Any, *, ctx: Transpiler) -> Expr:
+		return _math_call("exp", [ctx.emit_expr(x)])
+
+	@staticmethod
+	def exp2(x: Any, *, ctx: Transpiler) -> Expr:
+		# 2 ** x
+		return Binary(Literal(2), "**", ctx.emit_expr(x))
+
+	@staticmethod
+	def expm1(x: Any, *, ctx: Transpiler) -> Expr:
+		return _math_call("expm1", [ctx.emit_expr(x)])
+
+	@staticmethod
+	def fabs(x: Any, *, ctx: Transpiler) -> Expr:
+		return _math_call("abs", [ctx.emit_expr(x)])
+
+	@staticmethod
+	def floor(x: Any, *, ctx: Transpiler) -> Expr:
+		return _math_call("floor", [ctx.emit_expr(x)])
+
+	@staticmethod
+	def fmod(x: Any, y: Any, *, ctx: Transpiler) -> Expr:
+		return Binary(ctx.emit_expr(x), "%", ctx.emit_expr(y))
+
+	@staticmethod
+	def hypot(*coords: Any, ctx: Transpiler) -> Expr:
+		return _math_call("hypot", [ctx.emit_expr(c) for c in coords])
+
+	@staticmethod
+	def isclose(
+		a: Any, b: Any, *, rel_tol: Any = 1e-9, abs_tol: Any = 0.0, ctx: Transpiler
+	) -> Expr:
+		# abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)
+		a_expr = ctx.emit_expr(a)
+		b_expr = ctx.emit_expr(b)
+		rel_tol_expr = ctx.emit_expr(rel_tol)
+		abs_tol_expr = ctx.emit_expr(abs_tol)
+
+		abs_diff = _math_call("abs", [Binary(a_expr, "-", b_expr)])
+		max_abs = _math_call(
+			"max", [_math_call("abs", [a_expr]), _math_call("abs", [b_expr])]
+		)
+		rel_bound = Binary(rel_tol_expr, "*", max_abs)
+		max_bound = _math_call("max", [rel_bound, abs_tol_expr])
+		return Binary(abs_diff, "<=", max_bound)
+
+	@staticmethod
+	def isfinite(x: Any, *, ctx: Transpiler) -> Expr:
+		return _number_call("isFinite", [ctx.emit_expr(x)])
+
+	@staticmethod
+	def isinf(x: Any, *, ctx: Transpiler) -> Expr:
+		# !Number.isFinite(x) && !Number.isNaN(x)
+		x_expr = ctx.emit_expr(x)
+		return Binary(
+			Unary("!", _number_call("isFinite", [x_expr])),
+			"&&",
+			Unary("!", _number_call("isNaN", [x_expr])),
+		)
+
+	@staticmethod
+	def isnan(x: Any, *, ctx: Transpiler) -> Expr:
+		return _number_call("isNaN", [ctx.emit_expr(x)])
+
+	@staticmethod
+	def isqrt(n: Any, *, ctx: Transpiler) -> Expr:
+		return _math_call("floor", [_math_call("sqrt", [ctx.emit_expr(n)])])
+
+	@staticmethod
+	def ldexp(x: Any, i: Any, *, ctx: Transpiler) -> Expr:
+		# x * (2 ** i)
+		return Binary(
+			ctx.emit_expr(x),
+			"*",
+			Binary(Literal(2), "**", ctx.emit_expr(i)),
+		)
+
+	@staticmethod
+	def log(value: Any, base: Any = None, *, ctx: Transpiler) -> Expr:
+		if base is None:
+			return _math_call("log", [ctx.emit_expr(value)])
+		return Binary(
+			_math_call("log", [ctx.emit_expr(value)]),
+			"/",
+			_math_call("log", [ctx.emit_expr(base)]),
+		)
+
+	@staticmethod
+	def log10(x: Any, *, ctx: Transpiler) -> Expr:
+		return _math_call("log10", [ctx.emit_expr(x)])
+
+	@staticmethod
+	def log1p(x: Any, *, ctx: Transpiler) -> Expr:
+		return _math_call("log1p", [ctx.emit_expr(x)])
+
+	@staticmethod
+	def log2(x: Any, *, ctx: Transpiler) -> Expr:
+		return _math_call("log2", [ctx.emit_expr(x)])
+
+	@staticmethod
+	def pow(x: Any, y: Any, *, ctx: Transpiler) -> Expr:
+		return _math_call("pow", [ctx.emit_expr(x), ctx.emit_expr(y)])
+
+	@staticmethod
+	def radians(x: Any, *, ctx: Transpiler) -> Expr:
+		# x * (PI / 180)
+		return Binary(
+			ctx.emit_expr(x),
+			"*",
+			Binary(_math_prop("PI"), "/", Literal(180)),
+		)
+
+	@staticmethod
+	def remainder(x: Any, y: Any, *, ctx: Transpiler) -> Expr:
+		# x - round(x/y) * y
+		x_expr = ctx.emit_expr(x)
+		y_expr = ctx.emit_expr(y)
+		n = _math_call("round", [Binary(x_expr, "/", y_expr)])
+		return Binary(x_expr, "-", Binary(n, "*", y_expr))
+
+	@staticmethod
+	def sin(x: Any, *, ctx: Transpiler) -> Expr:
+		return _math_call("sin", [ctx.emit_expr(x)])
+
+	@staticmethod
+	def sinh(x: Any, *, ctx: Transpiler) -> Expr:
+		return _math_call("sinh", [ctx.emit_expr(x)])
+
+	@staticmethod
+	def sqrt(x: Any, *, ctx: Transpiler) -> Expr:
+		return _math_call("sqrt", [ctx.emit_expr(x)])
+
+	@staticmethod
+	def tan(x: Any, *, ctx: Transpiler) -> Expr:
+		return _math_call("tan", [ctx.emit_expr(x)])
+
+	@staticmethod
+	def tanh(x: Any, *, ctx: Transpiler) -> Expr:
+		return _math_call("tanh", [ctx.emit_expr(x)])
+
+	@staticmethod
+	def trunc(x: Any, *, ctx: Transpiler) -> Expr:
+		return _math_call("trunc", [ctx.emit_expr(x)])
+
+	@staticmethod
+	def fma(x: Any, y: Any, z: Any, *, ctx: Transpiler) -> Expr:
+		# (x * y) + z
+		return Binary(
+			Binary(ctx.emit_expr(x), "*", ctx.emit_expr(y)),
+			"+",
+			ctx.emit_expr(z),
+		)

pulse/transpiler/modules/pulse/__init__.py

@@ -0,0 +1,5 @@
+"""Pulse module transpilation.
+
+Submodules:
+- tags: HTML tag functions -> JSX elements
+"""

pulse/transpiler/modules/pulse/tags.py

@@ -0,0 +1,250 @@
+"""HTML tag function transpilation to JSX elements.
+
+This module provides transpilation from pulse.dom.tags (like div, span, etc.)
+to JSX elements. Tag functions can be called with props and children:
+
+    # Python
+    div("Hello", className="container")
+
+    # JavaScript
+    <div className="container">Hello</div>
+"""
+
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass
+from typing import Any, final, override
+
+from pulse.components.for_ import emit_for
+from pulse.transpiler.nodes import (
+	Element,
+	Expr,
+	Literal,
+	Node,
+	Prop,
+	Spread,
+	spread_dict,
+)
+from pulse.transpiler.py_module import PyModule
+from pulse.transpiler.transpiler import Transpiler
+
+
+@dataclass(slots=True, frozen=True)
+class TagExpr(Expr):
+	"""Expr that creates JSX elements when called.
+
+	Represents a tag function like `div`, `span`, etc.
+	When called, produces an Element with props from kwargs and children from args.
+	"""
+
+	tag: str
+
+	@override
+	def emit(self, out: list[str]) -> None:
+		out.append(f'"{self.tag}"')
+
+	@override
+	def render(self):
+		return self.tag
+
+	@override
+	def transpile_call(
+		self,
+		args: list[ast.expr],
+		keywords: list[ast.keyword],
+		ctx: Transpiler,
+	) -> Expr:
+		"""Handle tag calls: positional args are children, kwargs are props.
+
+		Spread (**expr) is supported for prop spreading.
+		"""
+		# Build children from positional args
+		children: list[Node] = []
+		for a in args:
+			children.append(ctx.emit_expr(a))
+
+		# Build props from kwargs
+		props: list[tuple[str, Prop] | Spread] = []
+		key: str | Expr | None = None
+		for kw in keywords:
+			if kw.arg is None:
+				# **spread syntax
+				props.append(spread_dict(ctx.emit_expr(kw.value)))
+			else:
+				k = kw.arg
+				prop_value = ctx.emit_expr(kw.value)
+				if k == "key":
+					# Accept any expression as key for transpilation
+					if isinstance(prop_value, Literal) and isinstance(
+						prop_value.value, str
+					):
+						key = prop_value.value  # Optimize string literals
+					else:
+						key = prop_value  # Keep as expression
+				else:
+					props.append((k, prop_value))
+
+		return Element(
+			tag=self.tag,
+			props=props if props else None,
+			children=children if children else None,
+			key=key,
+		)
+
+	# -------------------------------------------------------------------------
+	# Python dunder methods: allow natural syntax in @javascript functions
+	# -------------------------------------------------------------------------
+
+	@override
+	def __call__(self, *args: Any, **kwargs: Any):  # pyright: ignore[reportIncompatibleMethodOverride]
+		"""Allow calling TagExpr objects in Python code.
+
+		Returns a placeholder Element for type checking. The actual transpilation
+		happens via transpile_call when the transpiler processes the AST.
+		"""
+		return Element(tag=self.tag, props=None, children=None, key=None)
+
+
+@final
+class PulseTags(PyModule):
+	"""Provides transpilation for pulse.dom.tags to JSX elements."""
+
+	# Regular tags
+	a = TagExpr("a")
+	abbr = TagExpr("abbr")
+	address = TagExpr("address")
+	article = TagExpr("article")
+	aside = TagExpr("aside")
+	audio = TagExpr("audio")
+	b = TagExpr("b")
+	bdi = TagExpr("bdi")
+	bdo = TagExpr("bdo")
+	blockquote = TagExpr("blockquote")
+	body = TagExpr("body")
+	button = TagExpr("button")
+	canvas = TagExpr("canvas")
+	caption = TagExpr("caption")
+	cite = TagExpr("cite")
+	code = TagExpr("code")
+	colgroup = TagExpr("colgroup")
+	data = TagExpr("data")
+	datalist = TagExpr("datalist")
+	dd = TagExpr("dd")
+	del_ = TagExpr("del")
+	details = TagExpr("details")
+	dfn = TagExpr("dfn")
+	dialog = TagExpr("dialog")
+	div = TagExpr("div")
+	dl = TagExpr("dl")
+	dt = TagExpr("dt")
+	em = TagExpr("em")
+	fieldset = TagExpr("fieldset")
+	figcaption = TagExpr("figcaption")
+	figure = TagExpr("figure")
+	footer = TagExpr("footer")
+	form = TagExpr("form")
+	h1 = TagExpr("h1")
+	h2 = TagExpr("h2")
+	h3 = TagExpr("h3")
+	h4 = TagExpr("h4")
+	h5 = TagExpr("h5")
+	h6 = TagExpr("h6")
+	head = TagExpr("head")
+	header = TagExpr("header")
+	hgroup = TagExpr("hgroup")
+	html = TagExpr("html")
+	i = TagExpr("i")
+	iframe = TagExpr("iframe")
+	ins = TagExpr("ins")
+	kbd = TagExpr("kbd")
+	label = TagExpr("label")
+	legend = TagExpr("legend")
+	li = TagExpr("li")
+	main = TagExpr("main")
+	map_ = TagExpr("map")
+	mark = TagExpr("mark")
+	menu = TagExpr("menu")
+	meter = TagExpr("meter")
+	nav = TagExpr("nav")
+	noscript = TagExpr("noscript")
+	object_ = TagExpr("object")
+	ol = TagExpr("ol")
+	optgroup = TagExpr("optgroup")
+	option = TagExpr("option")
+	output = TagExpr("output")
+	p = TagExpr("p")
+	picture = TagExpr("picture")
+	pre = TagExpr("pre")
+	progress = TagExpr("progress")
+	q = TagExpr("q")
+	rp = TagExpr("rp")
+	rt = TagExpr("rt")
+	ruby = TagExpr("ruby")
+	s = TagExpr("s")
+	samp = TagExpr("samp")
+	script = TagExpr("script")
+	section = TagExpr("section")
+	select = TagExpr("select")
+	small = TagExpr("small")
+	span = TagExpr("span")
+	strong = TagExpr("strong")
+	style = TagExpr("style")
+	sub = TagExpr("sub")
+	summary = TagExpr("summary")
+	sup = TagExpr("sup")
+	table = TagExpr("table")
+	tbody = TagExpr("tbody")
+	td = TagExpr("td")
+	template = TagExpr("template")
+	textarea = TagExpr("textarea")
+	tfoot = TagExpr("tfoot")
+	th = TagExpr("th")
+	thead = TagExpr("thead")
+	time = TagExpr("time")
+	title = TagExpr("title")
+	tr = TagExpr("tr")
+	u = TagExpr("u")
+	ul = TagExpr("ul")
+	var = TagExpr("var")
+	video = TagExpr("video")
+
+	# Self-closing tags
+	area = TagExpr("area")
+	base = TagExpr("base")
+	br = TagExpr("br")
+	col = TagExpr("col")
+	embed = TagExpr("embed")
+	hr = TagExpr("hr")
+	img = TagExpr("img")
+	input = TagExpr("input")
+	link = TagExpr("link")
+	meta = TagExpr("meta")
+	param = TagExpr("param")
+	source = TagExpr("source")
+	track = TagExpr("track")
+	wbr = TagExpr("wbr")
+
+	# SVG tags
+	svg = TagExpr("svg")
+	circle = TagExpr("circle")
+	ellipse = TagExpr("ellipse")
+	g = TagExpr("g")
+	line = TagExpr("line")
+	path = TagExpr("path")
+	polygon = TagExpr("polygon")
+	polyline = TagExpr("polyline")
+	rect = TagExpr("rect")
+	text = TagExpr("text")
+	tspan = TagExpr("tspan")
+	defs = TagExpr("defs")
+	clipPath = TagExpr("clipPath")
+	mask = TagExpr("mask")
+	pattern = TagExpr("pattern")
+	use = TagExpr("use")
+
+	# React fragment
+	fragment = TagExpr("")
+
+	# For component - maps to array.map()
+	For = emit_for

pulse/transpiler/modules/typing.py

@@ -0,0 +1,63 @@
+"""Python typing module transpilation - mostly no-ops for type hints."""
+
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass
+from typing import final, override
+
+from pulse.transpiler.nodes import Expr
+from pulse.transpiler.py_module import PyModule
+from pulse.transpiler.transpiler import Transpiler
+
+
+@dataclass(slots=True)
+class TypeHint(Expr):
+	"""A type hint that should never be emitted directly.
+
+	Used for typing constructs like Any that can be passed to cast() but
+	shouldn't appear in generated code.
+	"""
+
+	name: str
+
+	@override
+	def emit(self, out: list[str]) -> None:
+		raise TypeError(
+			f"Type hint '{self.name}' cannot be emitted as JavaScript. "
+			+ "It should only be used with typing.cast() or similar."
+		)
+
+	@override
+	def render(self):
+		raise TypeError(
+			f"Type hint '{self.name}' cannot be rendered. "
+			+ "It should only be used with typing.cast() or similar."
+		)
+
+	@override
+	def transpile_subscript(self, key: ast.expr, ctx: Transpiler) -> Expr:
+		# List[int], Optional[str], etc. -> still a type hint
+		return TypeHint(f"{self.name}[...]")
+
+
+@final
+class PyTyping(PyModule):
+	"""Provides transpilation for Python typing functions."""
+
+	# Type constructs used with cast() - error if emitted directly
+	Any = TypeHint("Any")
+	Optional = TypeHint("Optional")
+	Union = TypeHint("Union")
+	List = TypeHint("List")
+	Dict = TypeHint("Dict")
+	Set = TypeHint("Set")
+	Tuple = TypeHint("Tuple")
+	FrozenSet = TypeHint("FrozenSet")
+	Type = TypeHint("Type")
+	Callable = TypeHint("Callable")
+
+	@staticmethod
+	def cast(_type: ast.expr, val: ast.expr, *, ctx: Transpiler) -> Expr:
+		"""cast(T, val) -> val (type cast is a no-op at runtime)."""
+		return ctx.emit_expr(val)