MedICS Extension SDK

Python SDK for building extensions for the MedICS (Medical Image Computing and Segmentation) platform. Provides base classes, API utilities, and a CLI scaffolding tool.

Installation

pip install medics-extension-sdk

With Qt support (required for widget-based extensions):

pip install medics-extension-sdk[qt]      # PySide6 (recommended)
pip install medics-extension-sdk[pyqt6]   # PyQt6
pip install medics-extension-sdk[qt5]     # PyQt5 (legacy)

Development tools:

pip install medics-extension-sdk[dev]

Quick Start

1. Create an extension class

from medics_extension_sdk import BaseExtension

class MyExtension(BaseExtension):
    def __init__(self, parent=None):
        super().__init__(
            parent=parent,
            extension_name="My Extension",
            author_name="Your Name",
        )

    def get_version(self) -> str:
        return "1.0.0"

    def get_description(self) -> str:
        return "Does something useful with medical images"

    def get_category(self) -> str:
        return "Analysis"

    def create_widget(self, parent=None, **kwargs):
        from PySide6.QtWidgets import QLabel
        return QLabel("Hello from My Extension!")

The extension id is automatically derived: "your_name.my_extension".

2. Access platform services

# Inside any extension method:
self.log_message("Processing started")
value = self.get_config_value("my_ext", "threshold", 0.5)
self.set_config_value("my_ext", "threshold", 0.8)
self.send_event("processing_done", {"status": "ok"})
workspace = self.get_component("workspace_manager")

3. Expose a programmatic API

Decorate public methods with @api_method so they are auto-discovered at runtime:

from medics_extension_sdk import BaseExtension, api_method

class MyExtension(BaseExtension):
    ...

    @api_method(description="Run analysis and return results", category="Processing")
    def run_analysis(self, threshold: float = 0.5) -> dict:
        return {"threshold": threshold, "result": "ok"}

Retrieve the API from an instance:

ext = MyExtension()
api = ext.get_instance_api()   # returns apiDict of decorated callables
api.run_analysis(threshold=0.7)

Scaffolding

Generate a new extension template with the CLI:

medics-create-extension "My Segmentation Tool" \
    --author "Jane Doe" \
    --category "Segmentation" \
    --output ./extensions

This creates a fully-structured extension directory with a main class, widget, API methods, config file, and README.

API Reference

BaseExtension

ID format: {author_name}.{extension_name} — lowercased, spaces removed, non-alphanumeric characters replaced with _.

@api_method(description, category)

Marks a method for auto-discovery via get_instance_api().

apiDict

dict subclass with dot-notation attribute access.

Extension Categories

Standard categories for organizing extensions in the platform UI:

• "Analysis" — measurement and analysis tools
• "Segmentation" — segmentation algorithms
• "Visualization" — rendering and display
• "Processing" — image filters and transforms
• "Import/Export" — data I/O utilities
• "Workflow" — automation and pipeline tools
• "Utilities" — general helpers
• "Research" — experimental tools

Testing

import pytest
from medics_extension_sdk import BaseExtension

class MyExtension(BaseExtension):
    def __init__(self):
        super().__init__(extension_name="My Ext", author_name="Author")
    def get_version(self): return "1.0.0"
    def get_description(self): return "Test"

def test_id_readonly():
    ext = MyExtension()
    assert ext.id == "author.my_ext"
    with pytest.raises(AttributeError):
        ext.id = "hacked"

Run:

pytest tests/

Project Layout

Recommended structure for a published extension package:

my_extension/
+-- __init__.py          # exports Extension = MyExtensionClass
+-- my_extension.py      # main extension class
+-- icons/               # optional icon assets
+-- config.ini           # default configuration
+-- README.md

License

MIT - see LICENSE.