pulse-framework 0.1.38a9__tar.gz → 0.1.40__tar.gz

{pulse_framework-0.1.38a9 → pulse_framework-0.1.40}/PKG-INFO

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

{pulse_framework-0.1.38a9 → pulse_framework-0.1.40}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pulse-framework"
-version = "0.1.38a9"
+version = "0.1.40"
 description = "Pulse - Full-stack framework for building real-time React applications in Python"
 readme = "README.md"
 requires-python = ">=3.11"

{pulse_framework-0.1.38a9 → pulse_framework-0.1.40}/src/pulse/app.py

@@ -71,7 +71,7 @@ from pulse.middleware import (
 	Redirect,
 )
 from pulse.plugin import Plugin
-from pulse.proxy import PulseProxy
+from pulse.proxy import ReactProxyHandler
 from pulse.react_component import ReactComponent, registered_react_components
 from pulse.render_session import RenderSession
 from pulse.request import PulseRequest
@@ -335,11 +335,6 @@ class App:
 		self.setup(server_address)
 		self.status = AppStatus.running
 
-		# In single-server mode, the Pulse server acts as reverse proxy to the React server
-		if self.mode == "single-server":
-			return PulseProxy(
-				self.asgi, lambda: envvars.react_server_address, self.api_prefix
-			)
 		return self.asgi
 
 	def run(
@@ -379,28 +374,6 @@ class App:
 				**cors_config,
 			)
 
-		# Debug middleware to log CORS-related request details
-		# @self.fastapi.middleware("http")
-		# async def cors_debug_middleware(
-		# 	request: Request, call_next: Callable[[Request], Awaitable[Response]]
-		# ):
-		# 	origin = request.headers.get("origin")
-		# 	method = request.method
-		# 	path = request.url.path
-		# 	print(
-		# 		f"[CORS Debug] {method} {path} | Origin: {origin} | "
-		# 		+ f"Mode: {self.mode} | Server: {self.server_address}"
-		# 	)
-		# 	response = await call_next(request)
-		# 	allow_origin = response.headers.get("access-control-allow-origin")
-		# 	if allow_origin:
-		# 		print(f"[CORS Debug] Response allows origin: {allow_origin}")
-		# 	elif origin:
-		# 		logger.warning(
-		# 			f"[CORS Debug] Origin {origin} present but no Access-Control-Allow-Origin header set"
-		# 		)
-		# 	return response
-
 		# Mount PulseContext for all FastAPI routes (no route info). Other API
 		# routes / middleware should be added at the module-level, which means
 		# this middleware will wrap all of them.
@@ -419,8 +392,6 @@ class App:
 			)
 			render_id = request.headers.get("x-pulse-render-id")
 			render = self._get_render_for_session(render_id, session)
-			if render:
-				print(f"Reusing render session {render_id}")
 			with PulseContext.update(session=session, render=render):
 				res: Response = await call_next(request)
 			session.handle_response(res)
@@ -568,6 +539,26 @@ class App:
 		for plugin in self.plugins:
 			plugin.on_setup(self)
 
+		# In single-server mode, add catch-all route to proxy unmatched requests to React server
+		# This route must be registered last so FastAPI tries all specific routes first
+		# FastAPI will match specific routes before this catch-all, but we add an explicit check
+		# as a safety measure to ensure API routes are never proxied
+		if self.mode == "single-server":
+			proxy_handler = ReactProxyHandler(lambda: envvars.react_server_address)
+
+			@self.fastapi.api_route(
+				"/{path:path}",
+				methods=["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"],
+				include_in_schema=False,
+			)
+			async def proxy_catch_all(request: Request, path: str):  # pyright: ignore[reportUnusedFunction]
+				# Skip WebSocket upgrades (handled by Socket.IO)
+				if request.headers.get("upgrade", "").lower() == "websocket":
+					raise HTTPException(status_code=404, detail="Not found")
+
+				# Proxy all unmatched HTTP requests to React Router
+				return await proxy_handler(request)
+
 		@self.sio.event
 		async def connect(  # pyright: ignore[reportUnusedFunction]
 			sid: str, environ: dict[str, Any], auth: dict[str, str] | None
@@ -902,7 +893,6 @@ class App:
 			self._cancel_render_cleanup(rid)
 
 		# Close all render sessions
-		print("Closing app")
 		for rid in list(self.render_sessions.keys()):
 			self.close_render(rid)
 
@@ -939,7 +929,7 @@ class App:
 			return  # no active render for this user session
 
 		# We don't want to wait for this to resolve
-		create_task(render.call_api(f"/{self.api_prefix}/set-cookies", method="GET"))
+		create_task(render.call_api(f"{self.api_prefix}/set-cookies", method="GET"))
 		sess.scheduled_cookie_refresh = True
 
 

{pulse_framework-0.1.38a9 → pulse_framework-0.1.40}/src/pulse/middleware.py

@@ -1,15 +1,17 @@
 from __future__ import annotations
 
 from collections.abc import Callable, Sequence
-from typing import TYPE_CHECKING, Any, Generic, TypeVar, overload, override
-
-from pulse.messages import ClientMessage, ServerInitMessage
+from typing import Any, Generic, TypeVar, overload, override
+
+from pulse.messages import (
+	ClientMessage,
+	PrerenderPayload,
+	PrerenderResult,
+	ServerInitMessage,
+)
 from pulse.request import PulseRequest
 from pulse.routing import RouteInfo
 
-if TYPE_CHECKING:
-	from pulse.app import PrerenderPayload, PrerenderResult
-
 T = TypeVar("T")
 
 

pulse_framework-0.1.40/src/pulse/proxy.py

@@ -0,0 +1,98 @@
+"""
+Proxy handler for forwarding requests to React Router server in single-server mode.
+"""
+
+import logging
+from typing import Callable
+
+import httpx
+from fastapi.responses import StreamingResponse
+from starlette.background import BackgroundTask
+from starlette.requests import Request
+from starlette.responses import PlainTextResponse, Response
+
+logger = logging.getLogger(__name__)
+
+
+class ReactProxyHandler:
+	"""
+	Handles proxying HTTP requests to React Router server.
+	"""
+
+	get_react_server_address: Callable[[], str | None]
+	_client: httpx.AsyncClient | None
+
+	def __init__(self, get_react_server_address: Callable[[], str | None]):
+		"""
+		Args:
+		    get_react_server_address: Callable that returns the React Router server full URL (or None if not started)
+		"""
+		self.get_react_server_address = get_react_server_address
+		self._client = None
+
+	@property
+	def client(self) -> httpx.AsyncClient:
+		"""Lazy initialization of HTTP client."""
+		if self._client is None:
+			self._client = httpx.AsyncClient(
+				timeout=httpx.Timeout(30.0),
+				follow_redirects=False,
+			)
+		return self._client
+
+	async def __call__(self, request: Request) -> Response:
+		"""
+		Forward HTTP request to React Router server and stream response back.
+		"""
+		# Get the React server address
+		react_server_address = self.get_react_server_address()
+		if react_server_address is None:
+			# React server not started yet, return error
+			return PlainTextResponse(
+				"Service Unavailable: React server not ready", status_code=503
+			)
+
+		# Build target URL
+		url = react_server_address.rstrip("/") + request.url.path
+		if request.url.query:
+			url += "?" + request.url.query
+
+		# Extract headers, skip host header (will be set by httpx)
+		headers = {k: v for k, v in request.headers.items() if k.lower() != "host"}
+
+		try:
+			# Build request
+			req = self.client.build_request(
+				method=request.method,
+				url=url,
+				headers=headers,
+				content=request.stream(),
+			)
+
+			# Send request with streaming
+			r = await self.client.send(req, stream=True)
+
+			# Filter out headers that shouldn't be present in streaming responses
+			response_headers = {
+				k: v
+				for k, v in r.headers.items()
+				# if k.lower() not in ("content-length", "transfer-encoding")
+			}
+
+			return StreamingResponse(
+				r.aiter_raw(),
+				background=BackgroundTask(r.aclose),
+				status_code=r.status_code,
+				headers=response_headers,
+			)
+
+		except httpx.RequestError as e:
+			logger.error(f"Proxy request failed: {e}")
+			return PlainTextResponse(
+				"Bad Gateway: Could not reach React Router server", status_code=502
+			)
+
+	async def close(self):
+		"""Close the HTTP client."""
+		if self._client is not None:
+			await self._client.aclose()

pulse_framework-0.1.38a9/src/pulse/proxy.py

@@ -1,195 +0,0 @@
-"""
-Proxy ASGI app for forwarding requests to React Router server in single-server mode.
-"""
-
-import logging
-from collections.abc import Iterable
-from typing import Callable, cast
-
-import httpx
-from starlette.datastructures import Headers
-from starlette.types import ASGIApp, Receive, Scope, Send
-
-logger = logging.getLogger(__name__)
-
-
-class PulseProxy:
-	"""
-	ASGI app that proxies non-API requests to React Router server.
-
-	In single-server mode, Python FastAPI handles /_pulse/* routes and
-	proxies everything else to the React Router server running on an internal port.
-	"""
-
-	def __init__(
-		self,
-		app: ASGIApp,
-		get_react_server_address: Callable[[], str | None],
-		api_prefix: str = "/_pulse",
-	):
-		"""
-		Initialize proxy ASGI app.
-
-		Args:
-		    app: The ASGI application to wrap (socketio.ASGIApp)
-		    get_react_server_address: Callable that returns the React Router server full URL (or None if not started)
-		    api_prefix: Prefix for API routes that should NOT be proxied (default: "/_pulse")
-		"""
-		self.app: ASGIApp = app
-		self.get_react_server_address: Callable[[], str | None] = (
-			get_react_server_address
-		)
-		self.api_prefix: str = api_prefix
-		self._client: httpx.AsyncClient | None = None
-
-	@property
-	def client(self) -> httpx.AsyncClient:
-		"""Lazy initialization of HTTP client."""
-		if self._client is None:
-			self._client = httpx.AsyncClient(
-				timeout=httpx.Timeout(30.0),
-				follow_redirects=False,
-			)
-		return self._client
-
-	async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
-		"""
-		ASGI application handler.
-
-		Routes starting with api_prefix or WebSocket connections go to FastAPI.
-		Everything else is proxied to React Router.
-		"""
-		if scope["type"] != "http":
-			# Pass through non-HTTP requests (WebSocket, lifespan, etc.)
-			await self.app(scope, receive, send)
-			return
-
-		path = scope["path"]
-
-		# Check if path starts with API prefix or is a WebSocket upgrade
-		if path.startswith(self.api_prefix):
-			# This is an API route, pass through to FastAPI
-			await self.app(scope, receive, send)
-			return
-
-		# Check if this is a WebSocket upgrade request (even if not prefixed)
-		headers = Headers(scope=scope)
-		if headers.get("upgrade", "").lower() == "websocket":
-			# WebSocket request, pass through to FastAPI
-			await self.app(scope, receive, send)
-			return
-
-		# Proxy to React Router server
-		await self._proxy_request(scope, receive, send)
-
-	async def _proxy_request(self, scope: Scope, receive: Receive, send: Send) -> None:
-		"""
-		Forward HTTP request to React Router server and stream response back.
-		"""
-		# Get the React server address
-		react_server_address = self.get_react_server_address()
-		if react_server_address is None:
-			# React server not started yet, return error
-			await send(
-				{
-					"type": "http.response.start",
-					"status": 503,
-					"headers": [(b"content-type", b"text/plain")],
-				}
-			)
-			await send(
-				{
-					"type": "http.response.body",
-					"body": b"Service Unavailable: React server not ready",
-				}
-			)
-			return
-
-		# Build target URL
-		path = scope["path"]
-		query_string = scope.get("query_string", b"").decode("utf-8")
-		# Ensure react_server_address doesn't end with /
-		base_url = react_server_address.rstrip("/")
-		target_path = f"{base_url}{path}"
-		if query_string:
-			target_path += f"?{query_string}"
-
-		# Extract headers
-		headers: dict[str, str] = {}
-		for name, value in cast(Iterable[tuple[bytes, bytes]], scope["headers"]):
-			name = name.decode("latin1")
-			value = value.decode("latin1")
-
-			# Skip host header (will be set by httpx)
-			if name.lower() == "host":
-				continue
-
-			# Collect headers (handle multiple values)
-			existing = headers.get(name)
-			if existing:
-				headers[name] = f"{existing},{value}"
-			else:
-				headers[name] = value
-
-		# Read request body
-		body_parts: list[bytes] = []
-		while True:
-			message = await receive()
-			if message["type"] == "http.request":
-				body_parts.append(message.get("body", b""))
-				if not message.get("more_body", False):
-					break
-		body = b"".join(body_parts)
-
-		try:
-			# Forward request to React Router
-			method = scope["method"]
-			response = await self.client.request(
-				method=method,
-				url=target_path,
-				headers=headers,
-				content=body,
-			)
-
-			# Send response status
-			await send(
-				{
-					"type": "http.response.start",
-					"status": response.status_code,
-					"headers": [
-						(name.encode("latin1"), value.encode("latin1"))
-						for name, value in response.headers.items()
-					],
-				}
-			)
-
-			# Stream response body
-			await send(
-				{
-					"type": "http.response.body",
-					"body": response.content,
-				}
-			)
-
-		except httpx.RequestError as e:
-			logger.error(f"Proxy request failed: {e}")
-
-			# Send error response
-			await send(
-				{
-					"type": "http.response.start",
-					"status": 502,
-					"headers": [(b"content-type", b"text/plain")],
-				}
-			)
-			await send(
-				{
-					"type": "http.response.body",
-					"body": b"Bad Gateway: Could not reach React Router server",
-				}
-			)
-
-	async def close(self):
-		"""Close the HTTP client."""
-		if self._client is not None:
-			await self._client.aclose()