mellifera 0.2.0__py3-none-any.whl

mellifera/__init__.py

@@ -0,0 +1,8 @@
+from mellifera.executors import TrioExecutor, HAS_NSMAINTHREAD
+
+if HAS_NSMAINTHREAD:
+    from mellifera.executors import NSMainThreadExecutor
+
+from mellifera.orchestrator import Orchestrator
+from mellifera.service import Service, expose
+from mellifera.services import TrioService, NSMainThreadService

mellifera/executor.py

@@ -0,0 +1,61 @@
+from abc import ABC, abstractmethod
+
+from mellifera.service import Service
+
+class Executor(ABC):
+
+    @abstractmethod
+    def run_threadsafe(self, f, *args, **kwargs):
+        """Run function f with args and kwargs inside executor in a threadsafe matter
+
+        This function is threadsafe.
+        """
+        ...
+
+    @abstractmethod
+    def register_service(self, service: Service, name: str) -> None:
+        """Register `service` under `name`
+
+        Only makes the service known, does not automatically start it
+        """
+        ...
+
+    @abstractmethod
+    def start_service(self, service: Service) -> None:
+        """Start `service` eventually
+
+        Idempotent
+        """
+        ...
+
+    @abstractmethod
+    def stop_service(self, service: Service) -> None:
+        """Stop `service` eventually
+
+        Idempotent
+        """
+        ...
+
+    @abstractmethod
+    def stop_all(self) -> None:
+        """Stops all services
+
+        Idempotent
+        """
+        ...
+
+    @abstractmethod
+    def start_sync(self) -> None:
+        """Start the executor.
+
+        Returns after the executor is started (in a different thread or process)
+        """
+        ...
+
+    @abstractmethod
+    def run_sync(self) -> None:
+        """Run the executor
+
+        Returns after the executor is done
+        """
+        ...

mellifera/executors/__init__.py

@@ -0,0 +1,6 @@
+from mellifera.executors.trio import TrioExecutor
+try:
+    from mellifera.executors.nsmainthread import NSMainThreadExecutor
+    HAS_NSMAINTHREAD = True
+except ModuleNotFoundError:
+    HAS_NSMAINTHREAD = False

mellifera/executors/nsmainthread.py

@@ -0,0 +1,70 @@
+try:
+    from Foundation import NSThread
+    from libdispatch import dispatch_async, dispatch_sync, dispatch_get_main_queue
+except ModuleNotFoundError:
+    raise ModuleNotFoundError("To use mellifera.orchestrators.nsmainthread you need to have pyobjc installed and run on macos")
+
+from types import SimpleNamespace
+
+from mellifera.orchestrator import Orchestrator, threadsafe
+from mellifera.services.nsmainthread import NSMainThreadService
+from mellifera.service import Service
+from mellifera.executor import Executor
+
+from mellifera.service import ServiceState
+
+class NSMainThreadExecutor(Executor):
+    requires_run = True
+
+    def __init__(self, orchestrator) -> None:
+        self.orchestrator = orchestrator
+        self.service = None
+
+    def run_threadsafe(self, f, *args, **kwargs):
+        if NSThread.isMainThread():
+            return f(*args, **kwargs)
+        else:
+
+            def closure():
+                return f(*args, **kwargs)
+
+            return dispatch_sync(dispatch_get_main_queue(), closure)
+
+    @threadsafe
+    def register_service(self, service: Service, name: str) -> None:
+        assert isinstance(service, NSMainThreadService)
+        if self.service is not None:
+            raise ValueError(
+                "MainThreadOrchestrator has multiple services to manage, can only orchestrate a single MainThreadService"
+            )
+        self.service = service
+        service.register(self.orchestrator, self, name)
+
+
+    @threadsafe
+    def start_service(self, service: Service) -> None:
+        if self.service is not None and self.service != service:
+            raise ValueError(f"Can only start a single service, already starting {self.service}")
+        if self.service is None:
+            self.service = service
+            service.state = ServiceState.WILL_BE_STARTED
+
+    @threadsafe
+    def stop_service(self, service: Service) -> None:
+        assert isinstance(service, NSMainThreadService)
+        service.stop()
+
+    @threadsafe
+    def stop_all(self) -> None:
+        self.service.stop()
+
+    def start_sync(self) -> None:
+        raise NotImplementedError()
+
+    def run_sync(self) -> None:
+        if self.service:
+            try:
+                self.service.init_sync()
+                self.service.run_sync()
+            finally:
+                self.service.finalize_sync()

mellifera/executors/trio.py

@@ -0,0 +1,168 @@
+from typing import TYPE_CHECKING
+
+import trio
+import trio.lowlevel
+import threading
+import inspect
+import logging
+from queue import Queue
+from types import SimpleNamespace
+
+from mellifera.services.trio import TrioService, ServiceState
+from mellifera.orchestrator import Orchestrator, threadsafe
+from mellifera.service import Service
+from mellifera.executor import Executor
+
+
+class TrioExecutor(Executor):
+    requires_run = False
+
+    def __init__(self, orchestrator) -> None:
+        self.orchestrator = orchestrator
+        self.trio_token = None
+        self.services = []
+        self.logger = logging.getLogger("mellifera.executors.TrioExecutor")
+
+        self.nursery = None
+        self.to_start = []
+        self._thread = None
+        self._lock = threading.RLock()
+        self.stopped = trio.Event()
+
+        self.write_channel, self.read_channel = trio.open_memory_channel(100)
+
+    def run_threadsafe(self, f, *args, **kwargs):
+        self.logger.info(f"run_threadsafe {f.__name__}")
+
+        if inspect.iscoroutinefunction(f):
+            async def closure():
+                return await f(*args, **kwargs)
+            is_async = True
+        else:
+            def closure():
+                return f(*args, **kwargs)
+            is_async = False
+
+        if trio.lowlevel.in_trio_run():
+            if is_async:
+                try:
+                    return self.write_channel.send_nowait(closure)
+                except trio.BrokenResourceError as e:
+                    self.logger.info("broken ressource error")
+                    raise e
+
+            else:
+                return closure()
+        else:
+            # Orchestrator didn't start yet, use locking for synchronisation
+            if not self._thread:
+                with self._lock:
+                    if is_async:
+                        self.logger.info(f"run_threadsafe {f.__name__} with lock, trio.run")
+                        return trio.run(closure)
+                    else:
+                        self.logger.info(f"run_threadsafe {f.__name__} with lock, direct")
+                        return closure()
+            else:
+                if self.trio_token:
+                    if is_async:
+                        self.logger.info(f"run_threadsafe {f.__name__} with trio_token, from_thread.run")
+                        return trio.from_thread.run(closure, trio_token=self.trio_token)
+                    else:
+                        self.logger.info(f"run_threadsafe {f.__name__} with trio_token, from_thread.run_sync")
+                        return trio.from_thread.run_sync(
+                            closure, trio_token=self.trio_token
+                        )
+                else:
+                    raise ValueError(
+                        "Calling TrioOrchestrator.run_in_thread but trio_token is None"
+                    )
+
+    @threadsafe
+    def register_service(self, service: Service, name: str) -> None:
+        assert isinstance(service, TrioService)
+        service.register(self.orchestrator, self, name)
+        self.services.append(service)
+
+    @threadsafe
+    async def start_service(self, service):
+        if self.stopped.is_set():
+            raise ValueError("Trying to start a service when executor is already stopped")
+        if service.state == ServiceState.CONSTRUCTED or service.state == ServiceState.WILL_BE_STARTED:
+            if service.state == ServiceState.CONSTRUCTED:
+                service.state = ServiceState.WILL_BE_STARTED
+            self.services.append(service)
+            if self.nursery:
+                self.logger.info(f"starting running service {service.name}")
+                self.nursery.start_soon(self.run_service, service)
+            else:
+                self.to_start.append(service)
+        else:
+            raise ValueError(f"Service is in state {service.state}")
+
+    @threadsafe
+    async def stop_service(self, service):
+        try:
+            with trio.fail_after(5):
+                await service.stop()
+        except trio.TooSlowError:
+            with trio.move_on_after(10):
+                await service.cancel()
+
+    @threadsafe
+    async def stop_all(self):
+        for service in self.services:
+            self.stop_service(service)
+        await self.write_channel.aclose()
+
+    async def run_service(self, service):
+        self.logger.info(f"Running service {service.name}")
+        try:
+            self.logger.info(f"Initializing service {service.name}")
+            await service.init()
+            self.logger.info(f"Initialized service {service.name}")
+            self.logger.info(f"Running service {service.name}")
+            await service.run()
+            self.logger.info(f"Running service {service.name} Done")
+        finally:
+            self.logger.info(f"Finalizing service {service.name}")
+            await service.finalize()
+            self.logger.info(f"Finalizing service {service.name} Done")
+
+    async def start(self, queue: Queue) -> None:
+        trio_token = trio.lowlevel.current_trio_token()
+        queue.put(trio_token)
+        await self.run()
+
+    async def run(self) -> None:
+        async with trio.open_nursery() as nursery:
+            self.nursery = nursery
+            for service in self.to_start:
+                nursery.start_soon(self.run_service, service)
+            self.to_start = []
+
+            try:
+                async with self.read_channel:
+                    async for async_function in self.read_channel:
+                        await async_function()
+            except trio.ClosedResourceError:
+                pass
+
+    def start_sync(self) -> None:
+        try:
+            queue = Queue()
+            self._thread = threading.Thread(target=trio.run, args=(self.start, queue))
+            self._thread.start()
+            value = queue.get()
+            if isinstance(value, Exception):
+                raise value
+            else:
+                self.trio_token = value
+        except BaseException as e:
+            # self.logger.error("Exception occured during start_sync", exc_info=True)
+            # for name, service in self._services.items():
+            # self.logger.error(f"Service {name} is in state {service.state}")
+            raise e
+
+    def run_sync(self) -> None:
+        trio.run(self.run)

mellifera/orchestrator.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from types import SimpleNamespace
+import functools
+import logging
+
+from typing import TYPE_CHECKING, Any, Optional
+import threading
+
+from mellifera.executor import Executor
+from mellifera.services import TrioService, NSMainThreadService
+
+if TYPE_CHECKING:
+    from mellifera.service import Service
+
+def threadsafe(f):
+    @functools.wraps(f)
+    def inner(self, *args, **kwargs):
+        return self.run_threadsafe(f, self, *args, **kwargs)
+
+    return inner
+
+class Orchestrator:
+
+    def __init__(self, stop_on_finish=True) -> None:
+        self.logger = logging.getLogger("calsiprovis.orchestrator.ParentOrchestrator")
+        self.services = SimpleNamespace()
+
+        from mellifera.executors import TrioExecutor, HAS_NSMAINTHREAD
+        if HAS_NSMAINTHREAD:
+            from mellifera.executors import NSMainThreadExecutor
+
+
+        self.executors: dict[str, Executor] = {"trio": TrioExecutor(self)}
+
+        if HAS_NSMAINTHREAD:
+            self.executors["ns"] = NSMainThreadExecutor(self)
+
+        self.lock = threading.RLock()
+
+
+    def start_service(self, service: Service | str) -> None:
+        if isinstance(service, str):
+            service = self.get_service(service)
+        match service:
+            case TrioService():
+                self.executors["trio"].start_service(service)
+            case _:
+                raise ValueError(f"Cannot start service of type {type(service)}")
+
+    def stop_service(self, service: Service) -> None:
+        match service:
+            case TrioService():
+                self.executors["trio"].stop_service(service)
+            case NSMainThreadService():
+                self.executors["ns"].stop_service(service)
+            case _:
+                raise ValueError(f"Cannot start service of type {type(service)}")
+
+    def register_service(self, service: Service, name: str) -> None:
+        with self.lock:
+            match service:
+                case TrioService():
+                    self.executors["trio"].register_service(service, name)
+                case NSMainThreadService():
+                    if "ns" in self.executors:
+                        self.executors["ns"].register_service(service, name)
+                    else:
+                        raise ValueError("Cannot handle NSMainThreadService, as NSMainThreadExecutor is not available")
+                case _:
+                    raise ValueError(f"Cannot handle service of type {type(service)}")
+            setattr(self.services, name, service)
+
+    def get_service(self, name: str) -> Service:
+        with self.lock:
+            if hasattr(self.services, name):
+                return getattr(self.services, name)
+            else:
+                raise ValueError(f"Service with name `{name}` not found")
+
+    def run(self):
+        if "ns" in self.executors:
+            self.executors["trio"].start_sync()
+            self.executors["ns"].run_sync()
+        else:
+            self.executors["trio"].run_sync()
+
+    def stop_all(self):
+        for executor in self.executors.values():
+            executor.stop_all()
+

mellifera/service.py

@@ -0,0 +1,195 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from mellifera.orchestrator import Orchestrator
+    from logging import Logger
+    from mellifera.executor import Executor
+
+import trio
+from typing import final
+import logging
+from functools import wraps
+from enum import Enum
+
+
+
+class ServiceError(Exception):
+    pass
+
+
+class ServiceState(Enum):
+    NONE = 0
+    CONSTRUCTED = 1
+    WILL_BE_STARTED = 2
+    INITIATING = 3
+    INITIATED = 4
+    RUNNING = 5
+    STOPPING = 6
+    STOPPED = 7
+    SHUTDOWN_STARTED = 8
+    SHUTDOWN = 9
+
+
+def expose(f):
+    @wraps(f)
+    def _inner(service, *args, **kwargs):
+        if (not service.state == ServiceState.INITIATED) and (
+            not service.state == ServiceState.RUNNING
+        ):
+            raise RuntimeError(
+                f"Service `{service.name}` not running, but is in state {service.state}"
+            )
+        return service.orchestrator.run_threadsafe(f, service, *args, **kwargs)
+
+    return _inner
+
+
+class Service:
+
+    orchestrator: Orchestrator
+    executor: Executor
+    logger: Logger
+    name: str
+
+    def __init__(self) -> None:
+        self._state = ServiceState.NONE
+
+        self.initiated_event = trio.Event()
+        self.started_event = trio.Event()
+        self.stopped_event = trio.Event()
+        self.shutdown_event = trio.Event()
+
+
+    @property
+    def initiated(self):
+        return self.initiated_event.wait()
+
+    @property
+    def started(self):
+        return self.started_event.wait()
+
+    @property
+    def stopped(self):
+        return self.stopped_event.wait()
+
+    @property
+    def shutdown(self):
+        return self.shutdown_event.wait()
+
+    @property
+    def state(self) -> ServiceState:
+        return self._state
+
+    @state.setter
+    def state(self, state: ServiceState) -> None:
+        match state:
+            case ServiceState.NONE:
+                assert False
+            case ServiceState.CONSTRUCTED:
+                if self._state != ServiceState.NONE:
+                    raise ServiceError(
+                        f"Trying to set service {self.name} into state {state.name} which is in state {self.state.name}"
+                    )
+                self._state = state
+            case ServiceState.WILL_BE_STARTED:
+                if self._state != ServiceState.CONSTRUCTED:
+                    raise ServiceError(
+                        f"Trying to set service {self.name} into state {state.name} which is in state {self.state.name}"
+                    )
+                self._state = state
+            case ServiceState.INITIATING:
+                if self._state != ServiceState.WILL_BE_STARTED:
+                    raise ServiceError(
+                        f"Trying to set service {self.name} into state {state.name} which is in state {self.state.name}"
+                    )
+                self._state = state
+                self.logger.debug("Initiating")
+            case ServiceState.INITIATED:
+                if self._state != ServiceState.INITIATING:
+                    raise ServiceError(
+                        f"Trying to set service {self.name} into state {state.name} which is in state {self.state.name}"
+                    )
+                self._state = state
+                self.logger.debug("Initiating done")
+                self.initiated_event.set()
+            case ServiceState.RUNNING:
+                if self._state != ServiceState.INITIATED:
+                    raise ServiceError(
+                        f"Trying to set service {self.name} into state {state.name} which is in state {self.state.name}"
+                    )
+                self._state = state
+                self.logger.debug("Running")
+                self.started_event.set()
+            case ServiceState.STOPPING:
+                if self._state.value >= state.value:
+                    raise ServiceError(
+                        f"Trying to set service {self.name} into state {state.name} which is in state {self.state.name}"
+                    )
+                self._state = state
+                self.logger.debug("Stopping")
+            case ServiceState.STOPPED:
+                if (self._state != ServiceState.RUNNING) and (
+                    self._state != ServiceState.STOPPING
+                ):
+                    raise ServiceError(
+                        f"Trying to set service {self.name} into state {state.name} which is in state {self.state.name}"
+                    )
+                self._state = state
+                self.logger.debug("Stopped")
+                self.stopped_event.set()
+            case ServiceState.SHUTDOWN_STARTED:
+                self._state = state
+                self.logger.debug("Shutting Down")
+            case ServiceState.SHUTDOWN:
+                if self._state != ServiceState.SHUTDOWN_STARTED:
+                    raise ServiceError(
+                        f"Trying to set service {self.name} into state {state.name} which is in state {self.state.name}"
+                    )
+                self._state = state
+                self.logger.debug("Shutting Down Done")
+                self.shutdown_event.set()
+
+    def register(self, orchestrator, executor, name):
+        self.orchestrator = orchestrator
+        self.executor = executor
+        self.name = name
+        self._register()
+        self.state = ServiceState.CONSTRUCTED
+        self.logger = logging.getLogger(f"mellifera.service.{name}")
+
+    def _register(self):
+        pass
+
+    @final
+    def init_sync(self) -> None:
+        if self.state != ServiceState.CONSTRUCTED:
+            raise ServiceError(
+                f"Trying to initate a service that is in state {self.state.name}"
+            )
+        self.state = ServiceState.INITIATING
+        self._init_sync()
+        self.state = ServiceState.INITIATED
+
+    def _init_sync(self) -> None:
+        pass
+
+    @final
+    def shut_down_sync(self) -> None:
+        if self.state.value < ServiceState.STOPPED.value:
+            self.logger.error(
+                f"shut_down called for service {self.name}, but in state {self.state.name}"
+            )
+        if self.state.value == ServiceState.SHUTDOWN:
+            self.logger.error(
+                f"shut_down called for service {self.name}, but in state {self.state.name}"
+            )
+            return
+
+        self.state = ServiceState.SHUTDOWN_STARTED
+        self._shut_down_sync()
+        self.state = ServiceState.SHUTDOWN
+
+    def _shut_down_sync(self) -> None:
+        pass

mellifera/services/__init__.py

@@ -0,0 +1,3 @@
+from mellifera.services.trio import TrioService
+from mellifera.services.nsmainthread import NSMainThreadService
+

mellifera/services/nsmainthread.py

@@ -0,0 +1,61 @@
+from mellifera.service import Service, ServiceState, ServiceError
+from typing import final
+
+
+class NSMainThreadService(Service):
+
+    def stop_sync(self) -> None:
+        if self.state.value >= ServiceState.STOPPING.value:
+            return
+        if self.state == ServiceState.RUNNING:
+            self.state = ServiceState.STOPPING
+            self._stop_sync()
+        else:
+            self.state = ServiceState.STOPPING
+            self.state = ServiceState.STOPPED
+
+    def run_sync(self) -> None:
+        if self.state != ServiceState.INITIATED:
+            raise ServiceError(
+                f"Trying to initate a service that is in state {self.state.name}"
+            )
+        self.state = ServiceState.RUNNING
+
+        try:
+            self._run_sync()
+            self.stop_sync()
+        finally:
+            self.state = ServiceState.STOPPED
+            self._nursery = None
+
+    def _run_sync(self) -> None:
+        pass
+
+    @final
+    def stop(self) -> None:
+        if self.state.value >= ServiceState.STOPPING.value:
+            return
+        self.state = ServiceState.STOPPING
+        self._stop_sync()
+
+    def _stop_sync(self) -> None:
+        pass
+
+    @final
+    def shut_down_sync(self) -> None:
+        if self.state.value < ServiceState.STOPPED.value:
+            self.logger.error(
+                f"shut_down called for service {self.name}, but in state {self.state.name}"
+            )
+        if self.state == ServiceState.SHUTDOWN:
+            self.logger.error(
+                f"shut_down called for service {self.name}, but in state {self.state.name}"
+            )
+            return
+
+        self.state = ServiceState.SHUTDOWN_STARTED
+        self._shut_down_sync()
+        self.state = ServiceState.SHUTDOWN
+
+    def _shut_down_sync(self) -> None:
+        pass

mellifera/services/trio.py

@@ -0,0 +1,146 @@
+import trio
+from typing import final
+
+from mellifera.service import Service, ServiceState, ServiceError
+
+
+class TrioService(Service):
+
+    def __init__(self):
+        super().__init__()
+
+        self._nursery = None
+        self._trio_token = None
+        self._stopped = trio.Event()
+        self._default_is_running = trio.Event()
+        self._dependents = []
+        self._dependencies = []
+        self._requires = []
+        self.cancel_scope = trio.CancelScope()
+
+    @final
+    async def init(self) -> None:
+        if self.state != ServiceState.WILL_BE_STARTED:
+            raise ServiceError(
+                f"Trying to initate a service that is in state {self.state.name}"
+            )
+        assert self.name
+        assert self.orchestrator
+        assert self.executor
+        self.state = ServiceState.INITIATING
+
+        for dependency in self._dependencies:
+            self.orchestrator.start_service(dependency)
+        for dependency in self._dependencies:
+            await dependency.initiated
+        for dependency in self._requires:
+            await dependency.initiated
+        await self._init()
+        self.state = ServiceState.INITIATED
+
+    @final
+    async def run(self) -> None:
+        if self.state != ServiceState.INITIATED:
+            raise ServiceError(
+                f"Trying to initate a service that is in state {self.state.name}"
+            )
+        self.state = ServiceState.RUNNING
+
+        try:
+            with self.cancel_scope:
+                await self._run()
+            await self.stop()
+        finally:
+            self.state = ServiceState.STOPPED
+            self._nursery = None
+
+    @final
+    async def stop(self) -> None:
+        if self.state.value >= ServiceState.STOPPING.value:
+            return
+        if self.state == ServiceState.RUNNING:
+            self.state = ServiceState.STOPPING
+            for dependent in self._dependents:
+                self.logger.debug(f"Waiting for {dependent.name}")
+                await dependent.stopped
+                self.logger.debug(f"Waiting for {dependent.name} DONE")
+            await self._stop()
+        else:
+            self.state = ServiceState.STOPPING
+            self.state = ServiceState.STOPPED
+
+    def requires(self, name: str) -> Service:
+        if not self.orchestrator:
+            raise ValueError("Service is not attached to an orchestrator")
+        service = self.orchestrator.get_service(name)
+        self._requires.append(service)
+        return service
+
+    def depends_on(self, name: str) -> Service:
+        if not self.orchestrator:
+            raise ValueError("Service is not attached to an orchestrator")
+        service = self.orchestrator.get_service(name)
+        assert isinstance(service, TrioService)
+        self._dependencies.append(service)
+        service._dependents.append(self)
+        return service
+
+    def uses(self, name: str) -> Service:
+        if not self.orchestrator:
+            raise ValueError("Service is not attached to an orchestrator")
+        service = self.orchestrator.get_service(name)
+        return service
+
+
+
+    async def start(self, nursery: trio.Nursery, task_status=trio.TASK_STATUS_IGNORED) -> None:
+        task_status.started()
+        return
+
+
+    @final
+    async def cancel(self) -> None:
+        self.logger.debug("Cancelling")
+        if self._nursery:
+            self._nursery.cancel_scope.cancel()
+        self.logger.debug("Cancelling Done")
+
+    @final
+    async def finalize(self) -> None:
+        if self.state.value < ServiceState.STOPPED.value:
+            self.logger.error(
+                f"shut_down called for service {self.name}, but in state {self.state.name}"
+            )
+        if self.state == ServiceState.SHUTDOWN:
+            self.logger.error(
+                f"shut_down called for service {self.name}, but in state {self.state.name}"
+            )
+            return
+
+        self.state = ServiceState.SHUTDOWN_STARTED
+        await self._finalize()
+        self.state = ServiceState.SHUTDOWN
+
+    def _construct(self) -> None:
+        """Override to request other services
+        """
+        pass
+
+    async def _init(self) -> None:
+        """Override to customize initialization.
+
+        Aquire ressources here
+        """
+        pass
+
+    async def _run(self) -> None:
+        """Override to customize running behavior"""
+        await trio.sleep_forever()
+
+    async def _stop(self) -> None:
+        """Override to stop running"""
+        self.cancel_scope.cancel()
+
+    async def _finalize(self) -> None:
+        """Override to close all ressources aquired on _init"""
+        pass

mellifera-0.2.0.dist-info/METADATA

@@ -0,0 +1,12 @@
+Metadata-Version: 2.3
+Name: mellifera
+Version: 0.2.0
+Summary: Runs async services under trio and orchestrates them with a pyobjc NSMainThread service
+Requires-Dist: pyobjc-core>=12.0 ; sys_platform == 'darwin'
+Requires-Dist: trio>=0.32.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+Service Orchestrator
+
+Mellifera orchestrates async services with a mainthread service

mellifera-0.2.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+mellifera/__init__.py,sha256=P96Bx3MQntFnk4niGwkbA56aMgFtjxryd5buFQpFLNM,301
+mellifera/executor.py,sha256=xCGJEIC9h8h1GgtNNaAALWs8_kzrBrVhsLZVRegX04E,1326
+mellifera/executors/__init__.py,sha256=d7u4J3zwuEFzFxXYWK7gva4PkaooCfuPurAgJ76W0Jc,210
+mellifera/executors/nsmainthread.py,sha256=7BAJ0KaDX6VdtsRitQhMfIKHmpu4kVPdSr0hvzRFMkM,2333
+mellifera/executors/trio.py,sha256=u4OySuybuA84jK4lznBfjQHoo3WKc3sgstmj1eZpcXw,6268
+mellifera/orchestrator.py,sha256=8rxGaNkwtFbusGMJPmjvYkQUxyd4vJos6-vhN4dUC1E,3132
+mellifera/service.py,sha256=8aKbOEF5O6sGtuARONSJhfSzQAgvlE9BGJTvkspUyN4,6499
+mellifera/services/__init__.py,sha256=otvmQMlP7eFpOvU4UV4HSidxsHslv_-iXvLi0VGvyVY,113
+mellifera/services/nsmainthread.py,sha256=FmQxukzrvq_Y1xauqSm11q9jEQXQmY_d5S57nT_eth4,1804
+mellifera/services/trio.py,sha256=6Kox60XKszaTx0J7CK8IKaIwwAKh0ROgKJQ3vgpfYGo,4621
+mellifera-0.2.0.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+mellifera-0.2.0.dist-info/METADATA,sha256=GupC66Mu0SOBnnyt21v5mgWD4cnZzp1UplupH39kimI,389
+mellifera-0.2.0.dist-info/RECORD,,

mellifera-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.8.24
+Root-Is-Purelib: true
+Tag: py3-none-any