pineapple-pine 0.7.0__tar.gz → 0.7.2__tar.gz

{pineapple_pine-0.7.0 → pineapple_pine-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pineapple-pine
-Version: 0.7.0
+Version: 0.7.2
 Summary: Pineapple pipeline engine — Python runtime
 Author-email: Liam Huang <liam0205@hotmail.com>
 License-Expression: Apache-2.0

{pineapple_pine-0.7.0 → pineapple_pine-0.7.2}/pine/cli/server.py

@@ -7,7 +7,7 @@ import threading
 import time
 from http.server import BaseHTTPRequestHandler, HTTPServer
 from pathlib import Path
-from typing import Any
+from typing import Any, Callable
 
 from pine.engine import Engine, StaticResourceProvider
 from pine.errors import ConfigError, RegistryError, ValidationError
@@ -15,6 +15,8 @@ from pine.go_format import go_json_marshal
 
 _DEFAULT_MAX_BODY = 10 * 1024 * 1024  # 10MB
 
+Middleware = Callable[["_PineHandler", Callable[[], None]], None]
+
 
 class _ServerState:
     """Thread-safe mutable server state (engine + reload stats)."""
@@ -53,31 +55,53 @@ class _ServerState:
 class _PineHandler(BaseHTTPRequestHandler):
     state: _ServerState
     max_body: int
+    middlewares: list[Middleware]
 
     def log_message(self, format, *args):
         pass
 
-    def do_GET(self):
+    def _dispatch(self):
+        """Route request to internal handlers or 404."""
         path = self.path.split("?")[0]
-        if path == "/health":
-            self._json_response(200, {"status": "ok"})
-        elif path == "/stats":
-            self._handle_stats()
-        elif path == "/dag":
-            self._handle_dag()
-        elif path == "/execute":
-            self._method_not_allowed()
+        method = self.command
+
+        if method == "GET":
+            if path == "/health":
+                self._json_response(200, {"status": "ok"})
+            elif path == "/stats":
+                self._handle_stats()
+            elif path == "/dag":
+                self._handle_dag()
+            elif path == "/execute":
+                self._method_not_allowed()
+            else:
+                self._json_response(404, {"error": "not found"})
+        elif method == "POST":
+            if path == "/execute":
+                self._handle_execute()
+            elif path in ("/health", "/stats", "/dag"):
+                self._method_not_allowed()
+            else:
+                self._json_response(404, {"error": "not found"})
         else:
-            self._json_response(404, {"error": "not found"})
+            self._method_not_allowed()
+
+    def _run_middleware_chain(self):
+        """Execute middleware chain, then dispatch."""
+        chain = self.middlewares
+
+        def build_next(idx: int) -> Callable[[], None]:
+            if idx >= len(chain):
+                return self._dispatch
+            return lambda: chain[idx](self, build_next(idx + 1))
+
+        build_next(0)()
+
+    def do_GET(self):
+        self._run_middleware_chain()
 
     def do_POST(self):
-        path = self.path.split("?")[0]
-        if path == "/execute":
-            self._handle_execute()
-        elif path in ("/health", "/stats", "/dag"):
-            self._method_not_allowed()
-        else:
-            self._json_response(404, {"error": "not found"})
+        self._run_middleware_chain()
 
     def _method_not_allowed(self):
         self._json_response(405, {"error": "method not allowed"})
@@ -263,6 +287,75 @@ def _watch_config(state: _ServerState, config_path: str, resource_provider: Any,
             print(f"config reload failed: {e}", file=sys.stderr)
 
 
+class PineServer:
+    """Programmatic Pine server with middleware support.
+
+    Usage:
+        server = PineServer(config_path, port=9000)
+        server.add_middleware(my_middleware)
+        server.start()  # blocks
+    """
+
+    def __init__(self, config_path: str, *, port: int = 8080, host: str = "",
+                 max_body: int = _DEFAULT_MAX_BODY,
+                 resource_provider: Any = None):
+        from pine.operators import ensure_registered
+        ensure_registered()
+
+        self._config_path = config_path
+        self._host = host
+        self._port = port
+        self._max_body = max_body
+        self._resource_provider = resource_provider
+        self._middlewares: list[Middleware] = []
+        self._started = False
+        self._server: HTTPServer | None = None
+        self._stop_event = threading.Event()
+
+    def add_middleware(self, mw: Middleware):
+        if self._started:
+            raise RuntimeError("cannot add middleware after server has started")
+        self._middlewares.append(mw)
+
+    def start(self):
+        """Start the server (blocking)."""
+        self._started = True
+        config_data = Path(self._config_path).read_bytes()
+
+        try:
+            engine = Engine.create(config_data, resource_provider=self._resource_provider)
+        except (ConfigError, RegistryError) as e:
+            raise RuntimeError(f"error creating engine: {e}") from e
+
+        state = _ServerState(engine)
+
+        handler = type("Handler", (_PineHandler,), {
+            "state": state,
+            "max_body": self._max_body,
+            "middlewares": list(self._middlewares),
+        })
+
+        watcher = threading.Thread(
+            target=_watch_config,
+            args=(state, self._config_path, self._resource_provider, self._stop_event),
+            daemon=True,
+        )
+        watcher.start()
+
+        self._server = HTTPServer((self._host, self._port), handler)
+        print(f"Pine server listening on :{self._port}", file=sys.stderr)
+
+        try:
+            self._server.serve_forever()
+        except KeyboardInterrupt:
+            self.stop()
+
+    def stop(self):
+        self._stop_event.set()
+        if self._server:
+            self._server.shutdown()
+
+
 def main():
     from pine.operators import ensure_registered
     ensure_registered()
@@ -321,6 +414,7 @@ def main():
     handler = type("Handler", (_PineHandler,), {
         "state": state,
         "max_body": max_body,
+        "middlewares": [],
     })
 
     stop_event = threading.Event()

{pineapple_pine-0.7.0 → pineapple_pine-0.7.2}/pineapple_pine.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pineapple-pine
-Version: 0.7.0
+Version: 0.7.2
 Summary: Pineapple pipeline engine — Python runtime
 Author-email: Liam Huang <liam0205@hotmail.com>
 License-Expression: Apache-2.0

{pineapple_pine-0.7.0 → pineapple_pine-0.7.2}/pineapple_pine.egg-info/SOURCES.txt

@@ -47,4 +47,5 @@ pineapple_pine.egg-info/top_level.txt
 tests/test_bench.py
 tests/test_fixtures.py
 tests/test_fuzz.py
-tests/test_lua_pool.py
+tests/test_lua_pool.py
+tests/test_server.py

{pineapple_pine-0.7.0 → pineapple_pine-0.7.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pineapple-pine"
-version = "0.7.0"
+version = "0.7.2"
 description = "Pineapple pipeline engine — Python runtime"
 requires-python = ">=3.11"
 license = "Apache-2.0"

pineapple_pine-0.7.2/tests/test_server.py

@@ -0,0 +1,196 @@
+"""Server extensibility tests for pine-python.
+
+Verifies:
+- Unknown paths return JSON 404 with {"error": "not found"}
+- Middleware can intercept custom paths (e.g. /metrics)
+- Method not allowed returns JSON 405
+"""
+from __future__ import annotations
+
+import json
+import threading
+import time
+from http.client import HTTPConnection
+from pathlib import Path
+from typing import Callable
+
+import pytest
+from pine.cli.server import PineServer, _PineHandler
+
+FIXTURES_ROOT = Path(__file__).parent.parent.parent / "fixtures"
+
+
+def _make_config() -> str:
+    """Create a minimal temp config file and return its path."""
+    cfg = {
+        "pipeline_config": {
+            "operators": {
+                "noop": {
+                    "type_name": "transform_copy",
+                    "direction": "common_to_common",
+                    "$metadata": {
+                        "common_input": ["x"],
+                        "common_output": ["y"],
+                        "item_input": [],
+                        "item_output": [],
+                    },
+                }
+            }
+        },
+        "pipeline_group": {"main": {"pipeline": ["noop"]}},
+        "flow_contract": {
+            "common_input": ["x"],
+            "item_input": [],
+            "common_output": ["x", "y"],
+            "item_output": [],
+        },
+    }
+    import tempfile
+
+    f = tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False)
+    json.dump(cfg, f)
+    f.close()
+    return f.name
+
+
+def _find_free_port() -> int:
+    import socket
+
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(("", 0))
+        return s.getsockname()[1]
+
+
+def _wait_ready(port: int, timeout: float = 5.0):
+    deadline = time.time() + timeout
+    while time.time() < deadline:
+        try:
+            conn = HTTPConnection("localhost", port, timeout=1)
+            conn.request("GET", "/health")
+            resp = conn.getresponse()
+            if resp.status == 200:
+                conn.close()
+                return
+            conn.close()
+        except (ConnectionRefusedError, OSError):
+            pass
+        time.sleep(0.1)
+    raise RuntimeError(f"Server on port {port} not ready within {timeout}s")
+
+
+class TestServerNotFound:
+    """Unknown paths must return JSON 404."""
+
+    @pytest.fixture(autouse=True)
+    def server(self):
+        config_path = _make_config()
+        port = _find_free_port()
+        srv = PineServer(config_path, port=port)
+        t = threading.Thread(target=srv.start, daemon=True)
+        t.start()
+        _wait_ready(port)
+        self.port = port
+        self.srv = srv
+        yield
+        srv.stop()
+        Path(config_path).unlink(missing_ok=True)
+
+    def test_unknown_path_returns_json_404(self):
+        conn = HTTPConnection("localhost", self.port)
+        conn.request("GET", "/unknown-path")
+        resp = conn.getresponse()
+        assert resp.status == 404
+        body = json.loads(resp.read())
+        assert body == {"error": "not found"}
+        assert "application/json" in resp.getheader("Content-Type", "")
+        conn.close()
+
+    def test_post_unknown_path_returns_json_404(self):
+        conn = HTTPConnection("localhost", self.port)
+        conn.request("POST", "/does-not-exist")
+        resp = conn.getresponse()
+        assert resp.status == 404
+        body = json.loads(resp.read())
+        assert body == {"error": "not found"}
+        conn.close()
+
+    def test_method_not_allowed_json(self):
+        conn = HTTPConnection("localhost", self.port)
+        conn.request("POST", "/health")
+        resp = conn.getresponse()
+        assert resp.status == 405
+        body = json.loads(resp.read())
+        assert body == {"error": "method not allowed"}
+        conn.close()
+
+
+class TestServerMiddleware:
+    """Middleware can intercept custom paths."""
+
+    @pytest.fixture(autouse=True)
+    def server(self):
+        config_path = _make_config()
+        port = _find_free_port()
+        srv = PineServer(config_path, port=port)
+
+        def metrics_middleware(handler: _PineHandler, next_fn: Callable[[], None]):
+            path = handler.path.split("?")[0]
+            if path == "/metrics":
+                handler._json_response(200, {"custom": True})
+                return
+            next_fn()
+
+        srv.add_middleware(metrics_middleware)
+        t = threading.Thread(target=srv.start, daemon=True)
+        t.start()
+        _wait_ready(port)
+        self.port = port
+        self.srv = srv
+        yield
+        srv.stop()
+        Path(config_path).unlink(missing_ok=True)
+
+    def test_middleware_intercepts_custom_path(self):
+        conn = HTTPConnection("localhost", self.port)
+        conn.request("GET", "/metrics")
+        resp = conn.getresponse()
+        assert resp.status == 200
+        body = json.loads(resp.read())
+        assert body["custom"] is True
+        conn.close()
+
+    def test_known_path_still_works(self):
+        conn = HTTPConnection("localhost", self.port)
+        conn.request("GET", "/health")
+        resp = conn.getresponse()
+        assert resp.status == 200
+        body = json.loads(resp.read())
+        assert body["status"] == "ok"
+        conn.close()
+
+    def test_unknown_path_not_intercepted(self):
+        conn = HTTPConnection("localhost", self.port)
+        conn.request("GET", "/other")
+        resp = conn.getresponse()
+        assert resp.status == 404
+        body = json.loads(resp.read())
+        assert body == {"error": "not found"}
+        conn.close()
+
+
+class TestServerMiddlewareCannotAddAfterStart:
+    """Adding middleware after start raises RuntimeError."""
+
+    def test_add_middleware_after_start_raises(self):
+        config_path = _make_config()
+        port = _find_free_port()
+        srv = PineServer(config_path, port=port)
+        t = threading.Thread(target=srv.start, daemon=True)
+        t.start()
+        _wait_ready(port)
+        try:
+            with pytest.raises(RuntimeError, match="cannot add middleware"):
+                srv.add_middleware(lambda h, n: n())
+        finally:
+            srv.stop()
+            Path(config_path).unlink(missing_ok=True)