pinexq-procon 2.1.0.dev3__py3-none-any.whl

pinexq/procon/runtime/worker.py

@@ -0,0 +1,437 @@
+import asyncio
+import logging
+from asyncio import CancelledError, Task
+from typing import Awaitable, Callable, TypeVar, Union
+
+import pydantic
+
+from ..core.exceptions import (
+    ProConBadMessage,
+    ProConException,
+    ProConMessageRejected,
+    ProConShutdown,
+    ProConUnknownFunctionError,
+)
+from ..core.naming import escape_version_string, is_valid_version_string
+from ..remote.messages import (
+    JobOfferMessageBody,
+    WorkerCommandMessageBody,
+    WorkerStatus,
+)
+from ..remote.rabbitmq import QueueSubscriber, RabbitMQClient
+from ..step import Step
+from .job import FunctionVersion, ProConJob
+from .settings import JOB_OFFERS_TOPIC
+from .tool import handle_task_result
+
+
+log = logging.getLogger(__name__)
+
+T = TypeVar('T')  # Any type.
+CallableOrAwaitable = Union[Callable[[T], bool], Callable[[T], Awaitable[bool]]]
+
+
+class WorkerCommunicationRMQ:
+    """Worker-specific communication using RabbitMQ"""
+    rmq_client: RabbitMQClient
+    _job_offer_subs: list[QueueSubscriber]
+    _outgoing_msg_queue: asyncio.Queue
+    _worker_cmd_cb: CallableOrAwaitable[WorkerCommandMessageBody] | None
+
+    def __init__(
+            self,
+            rmq_parameters: dict,
+            sender_id: str,
+            worker_id: str,
+            context_id: str,
+            functions: list[FunctionVersion],
+            msg_queue: asyncio.Queue,
+            worker_cmd_cb: CallableOrAwaitable[WorkerCommandMessageBody] | None = None,
+    ):
+        self.sender_id = sender_id
+        self.worker_id = worker_id
+        self.context_id = context_id
+        self._functions = functions
+        self._outgoing_msg_queue = msg_queue
+        self._worker_cmd_cb = worker_cmd_cb
+        self._job_offer_subs = []
+
+        self.is_initialized = False
+
+        self.rmq_parameters = rmq_parameters
+        self.rmq_client = RabbitMQClient(**rmq_parameters)
+
+    async def start(self):
+        """Connect to the RabbitMQ server and start accepting jobs"""
+        await self.rmq_client.connect_and_run()
+        await self._connect_to_worker_queues(self._functions)
+
+    async def stop(self):
+        """Stop receiving jobs and disconnect from RMQ server"""
+        await self.disconnect_from_worker_queues()
+        await self.rmq_client.close()
+
+    @property
+    def is_ready_to_send(self) -> bool:
+        """Returns if connection to RMQ server is established and queues initialized."""
+        return self.rmq_client.is_connected and self.is_initialized
+
+    async def report_worker_state(self, status: WorkerStatus | str):
+        """Log the current state of the worker"""
+        log.info(f"Worker state changed to: '{status.value}'")
+
+    async def report_worker_error(self, title: str, exception: Exception | None = None):
+        """Log error message from an exception"""
+        if exception:
+            log.exception(f"Error in worker: {title}", exc_info=exception)
+        else:
+            log.error(f"Error in worker: {title}")
+
+    async def _create_job_offer_subscription(self, func_name: str, func_version: str) -> QueueSubscriber | None:
+        topic = JOB_OFFERS_TOPIC.format(ContextId=self.context_id, FunctionName=func_name, Version=func_version)
+        # log.debug("Subscribing to Job.Offers queue: '%s'", topic)
+        exists = await self.rmq_client.does_queue_exist(topic)
+        if exists:
+            return await self.rmq_client.subscriber(
+                queue_name=topic,
+                routing_key=topic,
+                callback=self.on_job_offer_message
+            )
+        else:
+            return None
+
+    async def _connect_to_worker_queues(self, functions: list[FunctionVersion]):
+        """
+        Create the worker command channel, subscribe to the status channel,
+        and subscribe to a `job.offer` channel for each function this worker publishes.
+
+        Args:
+            functions: List of tuples with ("the_function_name", "version")
+        """
+
+        self._job_offer_subs = []
+        for f in functions:
+            sub = await self._create_job_offer_subscription(func_name=f.name, func_version=f.version)
+            if sub:
+                self._job_offer_subs.append(sub)
+                log.info(f"Listening for JobOffers: {f.name}:{f.version}")
+            else:
+                log.warning(f"Could not connect to JobOffers of: {f.name}:{f.version}")
+
+        if not self._job_offer_subs:
+            log.critical(msg:="Failed to connect to any Job.Offer queues!")
+            raise ProConException(msg)
+
+        self.is_initialized = True
+
+    async def disconnect_from_worker_queues(self):
+        """Stop listening to job.offer queues and stop & delete the command queue for this worker."""
+        if not self.is_initialized:
+            return
+        await asyncio.gather(
+            *(sub.stop_consumer_loop() for sub in self._job_offer_subs)
+        )
+
+        self.is_initialized = False
+
+    async def start_consuming_job_offers(self):
+        """Start polling on all `job.offer` queues."""
+        try:
+            async with asyncio.TaskGroup() as group:
+                for i, sub in enumerate(self._job_offer_subs):
+                    group.create_task(sub.run_consumer_loop(), name=f"job-offer-consumer-{i}")
+
+        except ExceptionGroup as eg:
+            for exc in eg.exceptions:
+                log.error(f"Error in Job.Offer consumer loop! {exc}")
+                # log.exception("Error in Job.Offer consumer loop!", exc_info=exc)
+            raise
+
+    async def stop_consuming_job_offers(self):
+        """Stop polling on all `job.offer` queues."""
+        await asyncio.gather(
+            *(sub.stop_consumer_loop() for sub in self._job_offer_subs)
+        )
+
+    #  Protocol handlers ------------------------
+
+    async def on_job_offer_message(self, message: str | bytes):
+        """Process the raw message body of incoming job.offers"""
+        try:
+            job_offer_msg = JobOfferMessageBody.model_validate_json(message)
+        except pydantic.ValidationError as ex:
+            msg = "Deserialization of 'job.offer' message failed!"
+            await self.report_worker_error(msg, exception=ex)
+            log.exception("⚠ %s", msg, exc_info=ex)
+            raise ProConBadMessage(msg) from ex
+        else:
+            log.debug("'job.offer' message deserialized: %s", str(job_offer_msg))
+            try:
+                self._outgoing_msg_queue.put_nowait(job_offer_msg)
+            except asyncio.QueueFull:
+                # A full message queue indicates that the worker is busy. The worker
+                # should have stopped receiving further job.offer messages. If we
+                # receive a message nonetheless (e.g. due to concurrency or prefetch)
+                # reject the message back to the queue.
+                raise ProConMessageRejected("Worker busy -> Job.offer rejected!")
+
+    async def on_worker_cmd_message(self, message: str | bytes):
+        """Process the raw message body of incoming worker.commands"""
+        try:
+            job_cmd_msg = WorkerCommandMessageBody.model_validate_json(message)
+        except pydantic.ValidationError as ex:
+            job_cmd_msg = "Deserialization of 'worker.command' message failed!"
+            await self.report_worker_error(job_cmd_msg, exception=ex)
+            log.exception("⚠ %s", job_cmd_msg, exc_info=ex)
+        else:
+            log.debug("'worker.command' message deserialized: %s", str(job_cmd_msg))
+            raise NotImplementedError('Worker commands not yet supported!')
+            # if self._worker_cmd_cb is not None:
+            #     result = self._worker_cmd_cb(job_cmd_msg)
+            #     if isawaitable(result):
+            #         await result
+
+
+class ProConWorker:
+    """
+    Worker class providing a `Step` function as remote resource via RabbitMQ
+    and handling its execution.
+
+    This class is instantiated and supervised by the Foreman class.
+    """
+
+    _job_task: Task | None = None
+    _processing_task: Task | None = None
+    _worker_com: WorkerCommunicationRMQ
+    _busy_lock: asyncio.BoundedSemaphore
+    _message_queue: asyncio.Queue
+    _running: asyncio.Event
+
+    step: Step
+    connected: bool
+    available_functions: dict[str, str]
+    configured_functions: dict[str, str]
+
+    def __init__(
+        self,
+        step: Step,
+        function_names: list[str],
+        rmq_parameters: dict,
+        worker_id: str,
+        context_id: str,
+        idle_timeout: int = 0,
+    ):
+        """Initialize a worker that can offer multiple Step functions for remote execution.
+        Functions are executed one at a time according to job.offer messages received via
+        RabbitMQ (RMQ) queues.
+
+        Args:
+            step: Step class containing the functions.
+            function_names: A list of function names to be offered remotely.
+            rmq_parameters: RabbitMQ connection parameters.
+            worker_id: Unique identifier for this worker.
+            context_id: Context id this worker is running in.
+            idle_timeout: Maximum idle time in seconds
+        """
+        log.info("Initializing worker for function '%s'", function_names)
+        self.worker_id = worker_id
+        self.context_id = context_id
+        self.step = step
+        self.connected = False
+
+        # Functions as defined in the `Step` class (name and version)
+        self.available_functions = {
+            name: escape_version_string(signature.version)
+            for name, signature in self.step.step_signatures.items()
+        }
+
+        # Functions configured by the --function/-f commandline parameter
+        self.configured_functions = self.resolve_function_and_version(function_names)
+
+        # This event is set when the worker is actively receiving job.offers
+        self._running = asyncio.Event()
+
+        # Semaphore limiting the number of concurrently started Jobs.
+        # Currently, there is only one worker that can process a single job.
+        self._busy_lock = asyncio.BoundedSemaphore(value=1)
+
+        # Incoming job.offer messages are passed through this message queue.
+        # This limits the number of messages pre-fetched from the RMQ queue.
+        self._incoming_msg_queue = asyncio.Queue(maxsize=1)
+
+        self._worker_com = WorkerCommunicationRMQ(
+            rmq_parameters=rmq_parameters,  # TODO: make this a dataclass
+            sender_id=self.sender_id,
+            worker_id=self.worker_id,
+            context_id=self.context_id,
+            functions=[
+                FunctionVersion(name=name, version=version)
+                for name, version in self.configured_functions.items()
+            ],
+            msg_queue=self._incoming_msg_queue
+        )
+
+        self.idle_timeout = idle_timeout
+
+    async def run(self) -> None:
+        """Connect to the RabbitMQ server and start accepting jobs"""
+        try:
+            async with asyncio.TaskGroup() as group:
+                log.info("Starting worker communication ...")
+                await self._worker_com.start()
+                await self._worker_com.report_worker_state(WorkerStatus.starting)
+                group.create_task(self._worker_com.start_consuming_job_offers())
+
+                log.info("▶ Start processing jobs")
+                await self._worker_com.report_worker_state(WorkerStatus.running)
+
+                group.create_task(self.process_jobs(), name="process_jobs")
+
+        except* ProConShutdown as exc:
+            log.info(f"Worker is shutting down! Reason: {str(exc)}")
+
+        except* CancelledError:
+            log.warning("Worker got cancelled!")
+
+        except* ProConException as exc:
+            log.exception(f"Unhandled exception in worker! -> {str(exc)}")
+
+        finally:
+            log.info("⏹ Stopped processing jobs")
+            await self._worker_com.report_worker_state(WorkerStatus.exiting)
+            await self._worker_com.stop()
+
+    @property
+    def sender_id(self) -> str:
+        """Unique sender ID of this worker"""
+        return f"worker:{self.worker_id}"
+
+    def resolve_function_and_version(self, function_version_strings: list[str]) -> dict[str, str]:
+        """Resolves a list with "function_name:version" specifiers.
+        Check if container exposes the given function names,
+        substitute '*' with all available names and split off the version string.
+        """
+        # If the requested functions contain a wildcard, just return all available functions
+        if "*" in function_version_strings:
+            return self.available_functions
+
+        function_version_dict: dict[str, str] = {}
+        for s in function_version_strings:
+            # Split function+version string at the first colon
+            name, _, version = s.partition(":")
+
+            if name not in self.available_functions:
+                raise ProConUnknownFunctionError(f"Unknown function: '{name}'!", func_name=name)
+
+            # If no version was provided as parameter, return the version annotated at the function
+            if not version:
+                version = self.available_functions[name]
+            else:
+                if not is_valid_version_string(version):
+                    raise ValueError(f"Given version: '{version}' is not valid. Allowed: a-Z 0-9 and '_' '-' '.'")
+
+            # Ensure the version string contains no '.' so we don't mess with messaging
+            version = escape_version_string(version)
+
+            function_version_dict[name] = version
+
+        return function_version_dict
+
+    def check_function_from_offer(self, job_offer_msg: JobOfferMessageBody) -> FunctionVersion | None:
+        """Ensures that the function and version in the job.offer is available in this container."""
+
+        if (function_name := job_offer_msg.content.algorithm) not in self.configured_functions:
+            msg = (f"Received job offer for unknown function: '{function_name}'!"
+                   f" Available are: {list(self.configured_functions.keys())}")
+            log.error(msg)
+            raise ProConUnknownFunctionError(msg)
+
+        requested_version = escape_version_string(job_offer_msg.content.algorithm_version)
+        available_version = self.configured_functions[function_name]
+        if requested_version != available_version:
+            msg = (
+                f"Function '{function_name}' is available in version '{available_version}', "
+                f"but the requested version is: '{requested_version}'"
+            )
+            log.error(msg)
+            raise ProConUnknownFunctionError(msg)
+
+        return FunctionVersion(name=function_name, version=requested_version)
+
+    async def run_job(self, job_offer_msg: JobOfferMessageBody) -> None:
+        """Run a specific job according to a job.offer message."""
+
+        function_and_version = self.check_function_from_offer(job_offer_msg)
+
+        await self._busy_lock.acquire()
+        try:
+            job = ProConJob(
+                step=self.step,
+                function=function_and_version,
+                context_id=self.context_id,
+                job_offer=job_offer_msg.content,
+                _rmq_client=self._worker_com.rmq_client,
+            )
+            await job.start()
+            await job.process()
+        except Exception:
+            raise
+        finally:
+            self._busy_lock.release()
+
+    async def process_jobs(self):
+        """Processing loop for incoming `job.offer` messages."""
+        log.debug("🔄 Entering processing loop.")
+        self._running.set()
+        while self._running.is_set():
+            try:
+                if self.idle_timeout > 0:
+                    log.info(f"Idle timeout set to: {self.idle_timeout}s")
+                    async with asyncio.timeout(delay=self.idle_timeout):
+                        message = await self._incoming_msg_queue.get()
+                else:
+                    message = await self._incoming_msg_queue.get()
+
+            except (TimeoutError, asyncio.TimeoutError):
+                log.info(f"⌛ Idle timeout! Worker was idle for more than {self.idle_timeout}s.")
+                raise ProConShutdown("Idle-timeout exceeded")
+            except asyncio.CancelledError:
+                raise ProConShutdown("Processing loop canceled")
+
+            try:
+                self._job_task = asyncio.create_task(self.run_job(message), name="job_main")
+                await self._job_task
+            except CancelledError:
+                pass  # Wait for the computation to finish, when this task is cancelled
+            finally:
+                self._incoming_msg_queue.task_done()
+
+        self._running.clear()
+        log.debug("⏹ Exiting processing loop.")
+        raise ProConShutdown("Processing loop stopped")
+
+    async def stop(self, timeout: float | None = None) -> None:
+        """Stop the processing loop for incoming job offers.
+        If a job is still running, wait for the computation to finish."""
+        self._running.clear()
+        await self._worker_com.stop_consuming_job_offers()
+
+        # Wait for running jobs by waiting for the busy lock
+        if self._busy_lock.locked():
+            log.debug("Waiting for running Job to finish ...")
+            await asyncio.wait_for(self._busy_lock.acquire(), timeout=timeout)
+            self._busy_lock.release()
+
+        # Force the processing loop to exit, when waiting for the queue's .get()
+        if self._processing_task is not None:
+            self._processing_task.cancel()
+
+    def _on_idle_timeout(self) -> None:
+        """A wrapper to call self.stop() from synchronous code."""
+        log.info("Worker reached idle timeout. Shutting down ...")
+        self._stop_task = asyncio.create_task(self.stop(), name="stop-worker-task")
+        self._stop_task.add_done_callback(handle_task_result)
+
+    async def _on_worker_cmd(self, worker_cmd_msg: WorkerCommandMessageBody) -> None:
+        # TODO
+        raise NotImplementedError()

pinexq/procon/step/__init__.py

@@ -0,0 +1,3 @@
+# ruff: noqa: F401
+from .step import Step, ExecutionContext
+from .versioning import version

pinexq/procon/step/introspection.py

@@ -0,0 +1,234 @@
+import inspect
+from importlib.metadata import version as get_package_version
+from types import NoneType
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Tuple, Type
+
+import docstring_parser
+import pydantic
+from pydantic import Field
+
+from ..core.exceptions import ProConSchemaError
+from ..dataslots.annotation import RETURN_SLOT_NAME, SlotType, dataslot, get_dataslot_metadata
+from ..dataslots.dataslots import isdataslot
+from .schema import DataslotModel, DynamicParameters, DynamicReturns, FunctionModel
+from .versioning import get_version_metadata
+
+
+if TYPE_CHECKING:
+    from ..step import Step
+
+
+class StepClassInfo:
+    """Adapter to extract signatures from all methods in a step class."""
+
+    def __init__(self, step: "Step"):
+        self.cls = step
+        self.funcs = StepClassInfo.funcs_from_cls(step)
+
+    @staticmethod
+    def funcs_from_cls(cls: object) -> List[Tuple[str, Callable]]:
+        """Return a list with _(name, func)_ for all public functions in _cls_"""
+        return [
+            (name, f)
+            for name, f in inspect.getmembers(cls)
+            if not name.startswith("_") and inspect.ismethod(f)
+        ]
+
+    def get_func_schemas(self) -> Dict[str, "FunctionSchema"]:
+        return {name: FunctionSchema(f) for name, f in self.funcs}
+
+
+class FunctionSchema:
+    """Extract the signature of a given function from its annotations and docstrings"""
+
+    name: str
+    function: Callable[[Any], Any]
+    version: str
+
+    _docs: docstring_parser.Docstring
+    _returns_docs: str
+    _param_docs: dict[str, str]
+    _param_annotations: dict[str, inspect.Parameter]
+    _dataslot_annotations: dict[str, inspect.Parameter]
+
+    _decorator_slots: dict[str, dataslot]
+    _parameter_slots: dict[str, dataslot]
+    _signature: inspect.Signature
+
+    def __init__(self, function: Callable):
+        self.name = function.__name__
+        self.function = function
+        self.version = str(get_version_metadata(function))
+        self._signature = inspect.signature(function)
+        self._init_docstrings()
+        self._init_decorated_dataslots()
+        self._init_annotations()
+        self._init_annotated_dataslots()
+
+    def _init_docstrings(self):
+        self._docs = docstring_parser.parse(inspect.getdoc(self.function))
+        self._param_docs = {p.arg_name: p.description for p in self._docs.params}
+        self._returns_docs = self._docs.returns.description if self._docs.returns else ""
+
+    def _init_decorated_dataslots(self):
+        # Dataslots defined by function decorator
+        self._decorator_slots = get_dataslot_metadata(self.function)
+
+        # Validate for each dataslot that a parameter with that name exists
+        decorated_names = set(self._decorator_slots.keys()) - {RETURN_SLOT_NAME}
+        parameter_names = set(self._signature.parameters.keys())
+        if diff := decorated_names - parameter_names:
+            raise ProConSchemaError(
+                f"The dataslots {diff} of function '{self.name}' don't match any parameters name!"
+            )
+
+        # Update description for the return value with the docstring, if not set in decorator
+        if ((RETURN_SLOT_NAME in self._decorator_slots)
+                and not self._decorator_slots[RETURN_SLOT_NAME].description):
+            self._decorator_slots[RETURN_SLOT_NAME].description = self._returns_docs
+
+    def _init_annotations(self):
+        """Get the functions signature and sort between dataslot and "other" parameters."""
+        self._dataslot_annotations = {}
+        self._param_annotations = {}
+        sig = self._signature
+
+        # Check if all parameters and return values have type annotations
+        if (any((p.annotation is sig.empty for p in sig.parameters.values()))
+            or sig.return_annotation is sig.empty
+        ):
+            raise ProConSchemaError(
+                f"Can not generate schema for function '{self.name}'. Type annotation is missing!"
+            )
+
+        # Disallow wildcard `Any` or `object` type annotation
+        if (any((p.annotation in (Any, object) for p in sig.parameters.values()))
+            or sig.return_annotation in (Any, object)
+        ):
+            raise ProConSchemaError(
+                f"Can not generate schema for function '{self.name}'. "
+                f"Wildcard types like `Any` or `object` are not allowed for type annotations!"
+            )
+
+        for name, p in sig.parameters.items():
+            # Collect all parameters that are by type annotation or function decorator a Dataslot
+            if isdataslot(p.annotation) or (name in self._decorator_slots):
+                self._dataslot_annotations[name] = p
+            # ... everything else are regular parameters.
+            self._param_annotations[name] = p
+
+    def _init_annotated_dataslots(self):
+        """Create `dataslot` objects for all parameters with a `Dataslot` type annotation."""
+        self._parameter_slots = {}
+        for name, p in self._dataslot_annotations.items():
+            self._parameter_slots[name] = dataslot(
+                name=p.name, dtype=p.annotation, description=self._param_docs.get("name", "")
+            )
+
+    def _get_parameters_signature(self) -> Dict[str, tuple[Any, Field]]:
+        """Returns the parameters annotation combined with their docstring as a dict"""
+        params_schema = {}
+        for name, p in self._param_annotations.items():
+            params_schema[name] = (
+                p.annotation,  # parameter type
+                Field(
+                    title=name,
+                    default=p.default if p.default is not p.empty else ...,
+                    description=self._param_docs.get(name, None),
+                ),
+            )
+        return params_schema
+
+    def _get_return_signature(self) -> dict[str, tuple[Any, Field]]:
+        """Returns the return type combined with its docstring as a dict"""
+        return_type = self._signature.return_annotation
+        if self._signature.return_annotation in (self._signature.empty, None):
+            return_type = NoneType
+        returns_schema = {"value": (return_type, Field(..., description=self._returns_docs))}
+        return returns_schema
+
+    def get_parameters_model(self, exclude_dataslots: bool = False) -> Type[DynamicParameters]:
+        """Function parameters as pydantic model for schema generation"""
+        params_signature = self._get_parameters_signature()
+        if exclude_dataslots:
+            params_signature = {
+                n: p for n, p in params_signature.items() if n not in self.dataslots
+            }
+        return pydantic.create_model("Parameters", __base__=DynamicParameters, **params_signature)
+
+    def get_returns_model(self, exclude_dataslots: bool = False) -> Type[DynamicReturns]:
+        """Function's return type as pydantic model for schema generation"""
+        if exclude_dataslots and (RETURN_SLOT_NAME in self._decorator_slots):
+            returns_signature = {"value": (NoneType, Field(...))}
+        else:
+            returns_signature = self._get_return_signature()
+        return pydantic.create_model("Returns", __base__=DynamicReturns, **returns_signature)
+
+    @property
+    def dataslots(self) -> dict[str, dataslot]:
+        """Merge all dataslot information from decorators and type annotation"""
+        param_ds = self._parameter_slots
+        deco_ds = self._decorator_slots
+        # Look for a dataslots name in parameters and decorators,
+        # if not found create a default dataslot object and merge them.
+        dataslot_names = list(self._dataslot_annotations.keys())
+        if RETURN_SLOT_NAME in self._decorator_slots:
+            dataslot_names.append(RETURN_SLOT_NAME)
+        return {
+            name: (param_ds.get(name, dataslot(name))).update(deco_ds.get(name, dataslot(name)))
+            for name in dataslot_names
+        }
+
+    def get_dataslot_models(self) -> tuple[list[DataslotModel], list[DataslotModel]]:
+        """Create the signatures for the dataslots"""
+        input_dataslots = []
+        output_dataslots = []
+        for name, d in self.dataslots.items():
+            slot_model = DataslotModel(
+                name=d.alias or d.name,
+                title=d.title,
+                description=d.description,
+                mediatype=str(d.media_type), # user could use a strenum or similar
+                metadata={},
+                max_slots=d.max_slots,
+                min_slots=d.min_slots,
+
+            )
+
+            if d.slot_type is SlotType.INPUT:
+                input_dataslots.append(slot_model)
+            else:
+                output_dataslots.append(slot_model)
+        return input_dataslots, output_dataslots
+
+    @property
+    def signature(self) -> dict:
+        """Create the functions signature with a parameter list, return type and docstrings"""
+        in_ds, out_ds = self.get_dataslot_models()
+
+        return_schema = self.get_returns_model(exclude_dataslots=True).model_json_schema()
+
+        param_schema = None
+        p = self.get_parameters_model(exclude_dataslots=True)
+        if len(p.model_fields) > 0:
+            param_schema = p.model_json_schema()
+
+        fields = dict(
+            version=str(self.version),
+            function_name=self.name,
+            short_description=self._docs.short_description or "",
+            long_description=self._docs.long_description or "",
+            parameters=param_schema,
+            returns=return_schema,
+            input_dataslots=[m.model_dump() for m in in_ds],
+            output_dataslots=[m.model_dump() for m in out_ds],
+            procon_version=get_procon_version(),
+        )
+        return fields
+
+    def get_function_model(self) -> FunctionModel:
+        return FunctionModel(**self.signature)
+
+
+def get_procon_version() -> str:
+    return get_package_version("pinexq-procon")