engin 0.1.0b4__tar.gz → 0.1.0b5__tar.gz

{engin-0.1.0b4 → engin-0.1.0b5}/.github/workflows/benchmark.yaml

@@ -4,6 +4,9 @@ on:
   push:
     branches: [main]
 
+env:
+  UV_FROZEN: "1"
+
 jobs:
   benchmark-main:
     runs-on: ubuntu-latest

{engin-0.1.0b4 → engin-0.1.0b5}/.github/workflows/check.yaml

@@ -3,6 +3,9 @@ name: Check
 on:
   push:
 
+env:
+  UV_FROZEN: "1"
+
 jobs:
   check:
     name: python
@@ -40,6 +43,7 @@ jobs:
         run: uv run poe ci-test
 
       - name: Upload coverage reports to Codecov
+        if: matrix.os == 'ubuntu-latest'
         uses: codecov/codecov-action@v5
         with:
           token: ${{ secrets.CODECOV_TOKEN }}

{engin-0.1.0b4 → engin-0.1.0b5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: engin
-Version: 0.1.0b4
+Version: 0.1.0b5
 Summary: An async-first modular application framework
 Project-URL: Homepage, https://github.com/invokermain/engin
 Project-URL: Documentation, https://engin.readthedocs.io/en/latest/

{engin-0.1.0b4 → engin-0.1.0b5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "engin"
-version = "0.1.0b4"
+version = "0.1.0b5"
 description = "An async-first modular application framework"
 readme = "README.md"
 requires-python = ">=3.10"

{engin-0.1.0b4 → engin-0.1.0b5}/src/engin/_engin.py

@@ -10,7 +10,7 @@ from itertools import chain
 from types import FrameType
 from typing import ClassVar
 
-from anyio import create_task_group, get_cancelled_exc_class
+from anyio import create_task_group, open_signal_receiver
 
 from engin._assembler import AssembledDependency, Assembler
 from engin._dependency import Invoke, Provide, Supply
@@ -149,7 +149,7 @@ class Engin:
             except Exception as err:
                 name = invocation.dependency.name
                 LOG.error(f"invocation '{name}' errored, exiting", exc_info=err)
-                return
+                raise
 
         lifecycle = await self._assembler.build(Lifecycle)
 
@@ -177,10 +177,11 @@ class Engin:
             try:
                 async with supervisor:
                     await self._stop_requested_event.wait()
-            except get_cancelled_exc_class():
-                pass
+                    await self._shutdown()
+            except BaseException:
+                await self._shutdown()
+
             tg.cancel_scope.cancel()
-            await self._shutdown()
 
     async def start(self) -> None:
         """
@@ -217,7 +218,8 @@ class Engin:
         started.
         """
         self._stop_requested_event.set()
-        await self._stop_complete_event.wait()
+        if self._state == _EnginState.RUNNING:
+            await self._stop_complete_event.wait()
 
     def graph(self) -> list[Node]:
         """
@@ -236,24 +238,23 @@ class Engin:
         return self._state == _EnginState.SHUTDOWN
 
     async def _shutdown(self) -> None:
-        LOG.info("stopping engin")
-        await self._exit_stack.aclose()
-        self._stop_complete_event.set()
-        LOG.info("shutdown complete")
-        self._state = _EnginState.SHUTDOWN
+        if self._state == _EnginState.RUNNING:
+            LOG.info("stopping engin")
+            await self._exit_stack.aclose()
+            self._stop_complete_event.set()
+            LOG.info("shutdown complete")
+            self._state = _EnginState.SHUTDOWN
 
 
 async def _stop_engin_on_signal(stop_requested_event: Event) -> None:
     """
     A task that waits for a stop signal (SIGINT/SIGTERM) and notifies the given event.
     """
-    # try to gracefully handle sigint/sigterm
     if not _OS_IS_WINDOWS:
-        loop = asyncio.get_running_loop()
-        for signame in (signal.SIGINT, signal.SIGTERM):
-            loop.add_signal_handler(signame, stop_requested_event.set)
-
-        await stop_requested_event.wait()
+        with open_signal_receiver(signal.SIGINT, signal.SIGTERM) as recieved_signals:
+            async for signum in recieved_signals:
+                LOG.debug(f"received {signum.name} signal")
+                stop_requested_event.set()
     else:
         should_stop = False
 

engin-0.1.0b5/tests/acceptance/test_engin_signal_handling.py

@@ -0,0 +1,28 @@
+import asyncio
+import signal
+import sys
+
+import pytest
+
+from engin import Engin
+
+
+@pytest.mark.skipif(sys.platform == "win32", reason="`signal.raise_signal` not supported")
+async def test_engin_signal_handling_when_run():
+    engin = Engin()
+    task = asyncio.create_task(engin.run())
+    await asyncio.sleep(0.1)
+    signal.raise_signal(signal.SIGTERM)
+    await asyncio.sleep(0.1)
+    assert engin.is_stopped()
+    del task
+
+
+@pytest.mark.skipif(sys.platform == "win32", reason="`signal.raise_signal` not supported")
+async def test_engin_signal_handling_when_start():
+    engin = Engin()
+    await engin.start()
+    await asyncio.sleep(0.1)
+    signal.raise_signal(signal.SIGTERM)
+    await asyncio.sleep(0.1)
+    assert engin.is_stopped()

engin-0.1.0b5/tests/acceptance/test_error_in_invocation.py

@@ -0,0 +1,28 @@
+import asyncio
+
+import pytest
+
+from engin import Engin, Invoke
+
+
+async def test_error_in_invocation_when_run():
+    async def main() -> None:
+        raise ValueError("foo")
+
+    engin = Engin(Invoke(main))
+
+    with pytest.raises(ValueError, match="foo"):
+        await asyncio.wait_for(engin.run(), timeout=0.5)
+
+
+async def test_error_in_invocation_when_start():
+    async def main() -> None:
+        raise ValueError("foo")
+
+    engin = Engin(Invoke(main))
+
+    with pytest.raises(ValueError, match="foo"):
+        await asyncio.wait_for(engin.start(), timeout=0.5)
+
+    # check we can shutdown the app
+    await asyncio.wait_for(engin.stop(), timeout=0.5)

engin-0.1.0b4/tests/acceptance/test_error_in_shutdown.py → engin-0.1.0b5/tests/acceptance/test_error_in_lifecycle_shutdown.py

@@ -1,3 +1,4 @@
+import asyncio
 from contextlib import asynccontextmanager
 
 from starlette.applications import Starlette
@@ -29,13 +30,20 @@ def b(lifecycle: Lifecycle) -> None:
     lifecycle.append(_b_startup())
 
 
-async def test_error_in_shutdown():
+async def test_error_in_shutdown_when_start():
     engin = Engin(Invoke(a), Invoke(b))
 
-    await engin.start()
+    await asyncio.wait_for(engin.start(), timeout=0.5)
     assert B_LIFECYCLE_STATE == 1
 
-    await engin.stop()
+    await asyncio.wait_for(engin.stop(), timeout=0.5)
+    assert B_LIFECYCLE_STATE == 2
+
+
+async def test_error_in_shutdown_when_run():
+    engin = Engin(Invoke(a), Invoke(b))
+
+    await asyncio.wait_for(engin.run(), timeout=0.5)
     assert B_LIFECYCLE_STATE == 2
 
 

engin-0.1.0b4/tests/acceptance/test_error_in_start_up.py → engin-0.1.0b5/tests/acceptance/test_error_in_lifecycle_startup.py

@@ -42,8 +42,11 @@ async def test_error_in_startup_handled_when_start():
     await asyncio.wait_for(engin.start(), timeout=0.5)
     assert not B_LIFECYCLE_STATE
 
+    # check we can shutdown the app
+    await asyncio.wait_for(engin.stop(), timeout=0.5)
 
-async def test_error_in_startup_asgi():
+
+async def test_error_in_startup_asgi_handled_when_run():
     def asgi_type() -> ASGIType:
         return Starlette()
 
@@ -51,3 +54,16 @@ async def test_error_in_startup_asgi():
 
     await engin.run()
     assert not B_LIFECYCLE_STATE
+
+
+async def test_error_in_startup_asgi_handled_when_start():
+    def asgi_type() -> ASGIType:
+        return Starlette()
+
+    engin = ASGIEngin(Invoke(a), Invoke(b), Provide(asgi_type))
+
+    await asyncio.wait_for(engin.start(), timeout=0.5)
+    assert not B_LIFECYCLE_STATE
+
+    # check we can shutdown the app
+    await asyncio.wait_for(engin.stop(), timeout=0.5)

engin-0.1.0b5/tests/acceptance/test_error_in_provider.py

@@ -0,0 +1,35 @@
+import asyncio
+
+import pytest
+
+from engin import Engin, Invoke, Provide
+from engin.exceptions import ProviderError
+
+
+async def test_error_in_provider_when_run():
+    async def raise_value_error() -> int:
+        raise ValueError("foo")
+
+    async def main(foo: int) -> None:
+        return
+
+    engin = Engin(Provide(raise_value_error), Invoke(main))
+
+    with pytest.raises(ProviderError, match="foo"):
+        await asyncio.wait_for(engin.run(), timeout=0.5)
+
+
+async def test_error_in_provider_when_start():
+    async def raise_value_error() -> int:
+        raise ValueError("foo")
+
+    async def main(foo: int) -> None:
+        return
+
+    engin = Engin(Provide(raise_value_error), Invoke(main))
+
+    with pytest.raises(ProviderError, match="foo"):
+        await asyncio.wait_for(engin.start(), timeout=0.5)
+
+    # check we can shutdown the app
+    await asyncio.wait_for(engin.stop(), timeout=0.5)

engin-0.1.0b4/tests/acceptance/test_error_in_supervised_task.py → engin-0.1.0b5/tests/acceptance/test_error_in_supervisor_task.py

@@ -15,7 +15,7 @@ def supervise(supervisor: Supervisor) -> None:
 async def test_error_in_supervised_task_handled_when_run(caplog):
     caplog.set_level(logging.INFO)
     engin = Engin(Invoke(supervise))
-    await engin.run()
+    await asyncio.wait_for(engin.run(), timeout=0.5)
     assert "Process errored" in caplog.text
     assert engin.is_stopped()
 
@@ -23,7 +23,7 @@ async def test_error_in_supervised_task_handled_when_run(caplog):
 async def test_error_in_supervised_task_handled_when_start(caplog):
     caplog.set_level(logging.INFO)
     engin = Engin(Invoke(supervise))
-    await engin.start()
+    await asyncio.wait_for(engin.start(), timeout=0.5)
     await asyncio.sleep(0.1)
     assert "Process errored" in caplog.text
     assert engin.is_stopped()

{engin-0.1.0b4 → engin-0.1.0b5}/tests/test_engin.py

@@ -3,10 +3,7 @@ from collections.abc import Iterable
 from contextlib import asynccontextmanager
 from datetime import datetime
 
-import pytest
-
 from engin import Engin, Entrypoint, Invoke, Lifecycle, Provide
-from engin.exceptions import ProviderError
 from tests.deps import ABlock
 
 
@@ -62,19 +59,6 @@ async def test_engin_with_block():
     await engin.stop()
 
 
-async def test_engin_error_handling():
-    async def raise_value_error() -> int:
-        raise ValueError("foo")
-
-    async def main(foo: int) -> None:
-        return
-
-    engin = Engin(Provide(raise_value_error), Invoke(main))
-
-    with pytest.raises(ProviderError, match="foo"):
-        await engin.run()
-
-
 async def test_engin_with_entrypoint():
     provider_called = False
 

{engin-0.1.0b4 → engin-0.1.0b5}/uv.lock

@@ -211,7 +211,7 @@ toml = [
 
 [[package]]
 name = "engin"
-version = "0.1.0b3"
+version = "0.1.0b5"
 source = { editable = "." }
 dependencies = [
     { name = "anyio" },
@@ -293,16 +293,16 @@ wheels = [
 
 [[package]]
 name = "fastapi"
-version = "0.115.14"
+version = "0.116.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pydantic" },
     { name = "starlette" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ca/53/8c38a874844a8b0fa10dd8adf3836ac154082cf88d3f22b544e9ceea0a15/fastapi-0.115.14.tar.gz", hash = "sha256:b1de15cdc1c499a4da47914db35d0e4ef8f1ce62b624e94e0e5824421df99739", size = 296263, upload-time = "2025-06-26T15:29:08.21Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/20/38/e1da78736143fd885c36213a3ccc493c384ae8fea6a0f0bc272ef42ebea8/fastapi-0.116.0.tar.gz", hash = "sha256:80dc0794627af0390353a6d1171618276616310d37d24faba6648398e57d687a", size = 296518, upload-time = "2025-07-07T15:09:27.82Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/53/50/b1222562c6d270fea83e9c9075b8e8600b8479150a18e4516a6138b980d1/fastapi-0.115.14-py3-none-any.whl", hash = "sha256:6c0c8bf9420bd58f565e585036d971872472b4f7d3f6c73b698e10cffdefb3ca", size = 95514, upload-time = "2025-06-26T15:29:06.49Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/68/d80347fe2360445b5f58cf290e588a4729746e7501080947e6cdae114b1f/fastapi-0.116.0-py3-none-any.whl", hash = "sha256:fdcc9ed272eaef038952923bef2b735c02372402d1203ee1210af4eea7a78d2b", size = 95625, upload-time = "2025-07-07T15:09:26.348Z" },
 ]
 
 [[package]]

engin-0.1.0b4/tests/acceptance/test_engin_signal_handling.py

@@ -1,24 +0,0 @@
-import asyncio
-from asyncio import TaskGroup
-
-from engin import Engin
-from engin._engin import _EnginState
-
-
-async def test_engin_signal_handling():
-    engin = Engin()
-
-    async with TaskGroup() as tg:
-        tg.create_task(engin.run())
-        # give it time to startup
-        await asyncio.sleep(0.1)
-
-        assert engin._state == _EnginState.RUNNING
-
-        # closest thing to emulating the actual signal with subprocesses
-        engin._stop_requested_event.set()
-
-        # give it time to shutdown
-        await asyncio.sleep(0.1)
-
-        assert engin._state == _EnginState.SHUTDOWN