aisc-plugin-interface 0.2.4__tar.gz → 0.2.5__tar.gz

{aisc_plugin_interface-0.2.4 → aisc_plugin_interface-0.2.5}/PKG-INFO

@@ -1,7 +1,8 @@
 Metadata-Version: 2.4
 Name: aisc-plugin-interface
-Version: 0.2.4
-Summary: Add your description here
+Version: 0.2.5
+Summary: Plugin interface for the AISC evaluation framework
+Author-email: Sean Blevins <sean.blevins@uni.lu>
 Requires-Python: >=3.12
 Requires-Dist: pydantic>=2.12.5
 Requires-Dist: rich>=14.3.3

{aisc_plugin_interface-0.2.4 → aisc_plugin_interface-0.2.5}/pyproject.toml

@@ -1,7 +1,8 @@
 [project]
 name = "aisc-plugin-interface"
-version = "0.2.4"
-description = "Add your description here"
+version = "0.2.5"
+description = "Plugin interface for the AISC evaluation framework"
+authors = [{ name = "Sean Blevins", email = "sean.blevins@uni.lu" }]
 readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
@@ -16,10 +17,8 @@ build-backend = "hatchling.build"
 [tool.hatch.build.targets.wheel]
 packages = ["src/aisc_plugin_interface"]
 
-[tool.hatch.build]
-include = [
-  "src/aisc_plugin_interface/templates/*.tpl",
-]
+[tool.hatch.build.targets.sdist]
+include = ["src/aisc_plugin_interface"]
 
 [project.scripts]
 aisc-plugin-interface = "aisc_plugin_interface.cli:main"

aisc_plugin_interface-0.2.5/src/aisc_plugin_interface/__init__.py

@@ -0,0 +1,24 @@
+from aisc_plugin_interface.base_evaluation_plugin import (
+    BaseEvaluationPlugin,
+    PluginFeatureFlags,
+)
+from aisc_plugin_interface.input_providers.base_input_provider import BaseInputProvider
+from aisc_plugin_interface.decorators.metric import metric
+from aisc_plugin_interface.decorators.evaluation_input import evaluation_input
+from aisc_plugin_interface.models.measure import Measure, MetricVisualization, ChartType
+from aisc_plugin_interface.models.evaluation_input import InputDefinition, InputType
+from aisc_plugin_interface.models.task import TaskProgress
+
+__all__ = [
+    "BaseEvaluationPlugin",
+    "PluginFeatureFlags",
+    "BaseInputProvider",
+    "metric",
+    "evaluation_input",
+    "Measure",
+    "MetricVisualization",
+    "ChartType",
+    "InputDefinition",
+    "InputType",
+    "TaskProgress",
+]

aisc_plugin_interface-0.2.5/src/aisc_plugin_interface/base_evaluation_plugin.py

@@ -0,0 +1,444 @@
+import copy
+import inspect
+import logging
+from abc import ABC, abstractmethod
+from collections.abc import Iterable, Sized
+from typing import (
+    Any,
+    get_args,
+    get_origin,
+    Callable,
+    Tuple,
+    TypeAlias,
+    TypeVar,
+    Generic,
+    final,
+    Type,
+    Self,
+)
+
+from pydantic import BaseModel, Field
+
+from aisc_plugin_interface.decorators.evaluation_input import InputDefinition
+from aisc_plugin_interface.utils import classproperty
+from aisc_plugin_interface.models.task import TaskProgress
+from aisc_plugin_interface.input_providers.base_input_provider import BaseInputProvider
+from aisc_plugin_interface.models.measure import Measure, MetricVisualization, ChartType
+
+ProgressCallback: TypeAlias = Callable[[TaskProgress], None]
+ArtifactCallback: TypeAlias = Callable[[str, bytes], None]
+
+
+class PluginFeatureFlags(BaseModel):
+    can_parse_config_from_dataset: bool = Field(
+        False, description="Show the dataset dropdown"
+    )
+    show_dimensions_visualisation: bool = Field(
+        False, description="Show the dimensions visualisation on the results page"
+    )
+    extra: dict = Field({}, description="Additional feature flags")
+
+
+class BaseEvaluationPlugin[T: BaseModel](ABC):
+    """
+    Abstract Base Class for evaluation plugins.
+    Plugins should inherit from this class and provide a Pydantic model for their configuration.
+
+    Example:
+        class MyPlugin(BaseEvaluationPlugin[MyConfigModel]):
+            ...
+    """
+
+    # UI Schema for RJSF (react-jsonschema-form) to customize form appearance
+    form_ui_schema: dict = {}
+
+    # The plugin name that will be displayed in the UI
+    plugin_name: str | None = None
+
+    # Controls the icon displayed in the plugin list.
+    # Use a Material Design icon name https://fonts.google.com/icons
+    ui_icon: str | None = None
+
+    _input_definitions: list[InputDefinition] = []
+    _input_provider_types: dict[str, Type[BaseInputProvider]] = {}
+
+    def __init__(self):
+        self._input_provider_instances: dict[str, BaseInputProvider] = {}
+        self._progress_callback: ProgressCallback | None = None
+        self._artifact_callback: ArtifactCallback | None = None
+        self._logger = None
+
+    @classmethod
+    def is_direct_subclass(cls: type[Self]) -> bool:
+        return BaseEvaluationPlugin in cls.__bases__
+
+    @classproperty
+    def display_name(cls: type[Self]) -> str:
+        """
+        Returns a display name for the plugin.
+
+        If the class defines a `plugin_name` attribute, its value is returned.
+        If not, the class's name (`cls.__name__`) is used as a fallback.
+        """
+        # NOTE: use cls.plugin_name only if cls is direct subclass of BaseEvaluationPlugin
+        plugin_name = cls.plugin_name
+        default = cls.__name__
+
+        if cls.is_direct_subclass():
+            # cls is a direct subclass of BaseInputProvider
+            return plugin_name or default
+        else:
+            if plugin_name is None:
+                return default
+            # avoid using the plugin name that was set for the parent plugin
+            for base in cls.__bases__:
+                if (
+                    issubclass(base, BaseEvaluationPlugin)
+                    and plugin_name == base.plugin_name
+                ):
+                    return default
+            return plugin_name
+
+    @property
+    def logger(self):
+        """
+        Returns the cached logger for this plugin class.
+
+        The logger is shared across all instances of the class (per-class caching)
+        and named as "<module> - __name__".
+        """
+        if self._logger is None:
+            cls = self.__class__
+            self._logger = logging.getLogger(f"{cls.__module__} - {cls.__name__}")
+        return self._logger
+
+    @property
+    def feature_flags(self) -> PluginFeatureFlags:
+        """
+        Controls UI behavior on the frontend.
+        Override this property in your subclass to change defaults.
+        """
+        return PluginFeatureFlags()
+
+    @property
+    def input_definitions(self) -> list[InputDefinition]:
+        """
+        Controls the evaluation input form at evaluation creation
+        """
+        return self._input_definitions
+
+    @property
+    def display_icon(self) -> str:
+        """
+        Controls the icon displayed in the plugin list.
+        Use a Material Design icon name
+        https://fonts.google.com/icons
+
+        For a new plugin, either redefine this property, or set the class attribute `ui_icon`
+        """
+        return self.ui_icon or "extension"
+
+    @property
+    def config_type(self) -> type[T]:
+        """
+        Retrieves the Pydantic model type used for plugin configuration.
+        """
+        for base in getattr(self.__class__, "__orig_bases__", []):
+            if get_origin(base) is BaseEvaluationPlugin:
+                return get_args(base)[0]
+        raise TypeError("Could not determine Config type T")
+
+    def get_metrics(self) -> list[str]:
+        """
+        Returns a list of all metric names defined in this plugin via the @metric decorator.
+        """
+        metrics = []
+        for name, method in inspect.getmembers(self, predicate=inspect.ismethod):
+            if hasattr(method, "metric_name"):
+                metrics.append(method.metric_name)
+        return metrics
+
+    def get_metric_visualizations(self, config_data: dict) -> list[MetricVisualization]:
+        """
+        Returns a list of MetricVisualization objects to render a list of
+        visualizations on the front end and the metrics to display for each
+
+        The config_data could be used to define specific visualizations from the config
+
+        By default, returns a single visualization (TABLE) with all metrics
+        """
+        return [
+            MetricVisualization(chart_type=ChartType.TABLE, metrics=self.get_metrics())
+        ]
+
+    def export_metrics(self, *args, **kwargs) -> list[Measure]:
+        """
+        Executes all methods decorated with @metric and aggregates their results.
+        """
+        results: list[Measure] = []
+        for name, method in inspect.getmembers(self, predicate=inspect.ismethod):
+            if hasattr(method, "metric_name"):
+                metric_measures: list[Measure] = method(*args, **kwargs)
+                results.extend(metric_measures)
+        return results
+
+    @abstractmethod
+    def evaluate(self, config_data: dict) -> Any:
+        """
+        The main execution logic of the plugin.
+        Developers should process the dataset/model here and return an intermediate result
+        that will be passed to the metric methods.
+        """
+        raise NotImplementedError
+
+    @final
+    def _set_progress_callback(
+        self, progress_callback: ProgressCallback | None
+    ) -> None:
+        """
+        Internal: called by the evaluation runtime (eval module) to feedback progress reporting.
+        Plugin implementations should not call or override this.
+        """
+        if progress_callback is not None and not callable(progress_callback):
+            raise TypeError("Progress sink must be callable or None")
+        self._progress_callback = progress_callback
+
+    @final
+    def report_progress(self, task_progress: TaskProgress) -> None:
+        """
+        Public, stable API for plugin authors.
+        No-op if no sink is configured by the evaluation runtime.
+        """
+        if self._progress_callback is None:
+            return
+        self._progress_callback(task_progress)
+
+    @final
+    def progress_bar(
+        self,
+        iterable,
+        *,
+        total: int | None = None,
+        desc: str | None = None,
+        start: int = 0,
+        with_index: bool = False,
+        extra: dict | None = None,
+    ) -> "ProgressBar":
+        """
+        Wrap an iterable to yield items (optionally with index)
+        while emitting progress for each item that is processed.
+
+        Returns a ProgressBar yielding items (or index, item) with automatic progress reporting.
+
+        Args:
+            iterable: Items to iterate.
+            total: Optional total length.
+            desc: Label.
+            start: Enumeration start.
+            with_index: Yield index with items.
+            extra: Extra progress fields.
+        """
+        return ProgressBar(
+            iterable=iterable,
+            plugin=self,
+            total=total,
+            desc=desc,
+            start=start,
+            with_index=with_index,
+            extra=extra,
+        )
+
+    @final
+    def _set_artifact_callback(
+        self, artifact_callback: ArtifactCallback | None
+    ) -> None:
+        """Internal: called by the evaluation runtime to hook into artifact uploading."""
+        self._artifact_callback = artifact_callback
+
+    @final
+    def upload_artifact(self, name: str, content: bytes) -> None:
+        """
+        Public API for plugin authors to upload arbitrary files.
+        """
+        if self._artifact_callback:
+            self._artifact_callback(name, content)
+        else:
+            self.logger.warning(
+                f"Artifact callback not configured. Dropping artifact: {name}"
+            )
+
+    def set_input_content(self, name: str, file_content: bytes | None) -> None:
+        """
+        Called by the runtime. Instantiates the provider mapped via @input.
+        """
+        provider_cls = self._input_provider_types.get(name)
+        if provider_cls and file_content is not None:
+            self._input_provider_instances[name] = provider_cls(file_content)
+
+    def get_input_data(self, name: str) -> Any | None:
+        """
+        Get data from InputProvider using name set in evaluation_input decorator
+        """
+        provider = self._input_provider_instances.get(name)
+        if provider is None:
+            return None
+        return provider.get_data()
+
+    def get_config_form_schema(self) -> dict:
+        """
+        Generates a JSON Schema from the Pydantic config model for the frontend UI.
+        """
+        return self.config_type.model_json_schema(mode="validation")
+
+    def validate_config_form_data(self, config_form_data: dict) -> T:
+        """
+        Validates incoming form data from frontend UI/backend DB against the Pydantic config model.
+        """
+        return self.config_type.model_validate(config_form_data)
+
+    def get_config_form_ui_schema(self) -> dict:
+        """
+        Returns a deep copy of the UI schema for form customization.
+        """
+        return copy.deepcopy(self.form_ui_schema)
+
+    def form_schema_to_internal(self, form_schema: T) -> dict:
+        """
+        Optional: Converts the validated Pydantic model used for the UI form
+                  into a dict for internal use
+        This can be overridden to add/change the structure of the input config data
+        for use in the evaluate method
+        """
+        return form_schema.model_dump()
+
+    def get_full_schema(self) -> Tuple[dict, dict]:
+        """Helper to get the fresh, static baseline."""
+        return self.get_config_form_schema(), self.get_config_form_ui_schema()
+
+    # form_data passed here may be incomplete, so we don't validate and use MyConfigModel
+    # It is the developer's responsibility to check for and use data accordingly here
+    def on_config_change(self, form_data: T | None) -> Tuple[T | None, dict, dict]:
+        """
+        Hook called whenever the user changes a form value.
+        Allows the plugin to dynamically update the schema (e.g. drop downs),
+        the data (e.g. auto-fill), or the UI (e.g. hide fields).
+        """
+        # Default: Do nothing, just return what came in
+        schema, ui_schema = self.get_full_schema()
+        return form_data, schema, ui_schema
+
+    def parse_config_from_dataset(self, file_content: bytes) -> dict | None:
+        """
+        Optional: Try to parse a valid config from the dataset.
+        Use a InputProvider to read the file contents
+        """
+        return None
+
+
+Item = TypeVar("Item")
+
+
+class ProgressBar(Generic[Item]):
+    """
+    Iterator that wraps an iterable, yielding each item (and optionally its index)
+    and reporting progress via a plugin.
+
+    Each emit reports the progress for the current item that is processed.
+
+    Args:
+        iterable: Items to iterate over.
+        plugin: Receives progress reports (must implement `report_progress`).
+        total: Length of iteration (inferred if not given).
+        desc: Progress label.
+        start: Enumeration start index (min 1 if negative).
+        with_index: Yield (index, item) pairs if True.
+        extra: Extra fields for progress payloads.
+    """
+
+    def __init__(
+        self,
+        iterable: Iterable[Item],
+        *,
+        plugin: BaseEvaluationPlugin,
+        total: int | None = None,
+        desc: str | None = None,
+        start: int = 0,
+        with_index: bool = False,
+        extra: dict | None = None,
+    ):
+        self._start = start
+        self._with_index = with_index
+
+        # infer total if not provided
+        if total is None:
+            if isinstance(iterable, Sized):
+                total = len(iterable)
+            else:
+                iterable = list(iterable)
+                total = len(iterable)
+        self._total = total
+
+        self._desc = desc or ""
+        self._extra = {} if extra is None else extra.copy()
+
+        self._report_progress = getattr(plugin, "report_progress", None)
+
+        # prepare enumerate on iterable with correct start index
+        self._enumerated_iter = enumerate(iterable, start=self._start)
+
+        # start emitting at 0
+        self.emit(0)
+
+    @property
+    def desc(self) -> str:
+        return self._desc
+
+    def set_description(self, description: str):
+        self._desc = description
+
+    @property
+    def extra(self) -> dict:
+        return self._extra
+
+    def set_extra(self, fields: dict) -> None:
+        self._extra.update(fields)
+
+    def emit(self, i: int):
+        """
+        Report progress for index `i` using the plugin.
+        """
+        if self._report_progress and self._total:
+            progress = min(float(min(i, self._total)) / self._total, 1.0)
+            payload = {
+                "iteration": int(i),
+                "total": self._total,
+            }
+            if self._desc:
+                payload["desc"] = self._desc
+            if self._extra:
+                payload.update(self._extra)
+            self._report_progress(
+                TaskProgress(
+                    progress=progress,
+                    extra=payload,
+                )
+            )
+
+    def __len__(self) -> int:
+        return self._total
+
+    def __iter__(self) -> Self:
+        return self
+
+    def __next__(self) -> Item | tuple[int, Item]:
+        """
+        Yield the next item (and index if requested),
+        emitting progress for the current item being processed.
+
+        Raises:
+            StopIteration when exhausted.
+        """
+        idx, item = next(self._enumerated_iter)
+
+        self.emit(idx - self._start + 1)
+        return (idx, item) if self._with_index else item

aisc_plugin_interface-0.2.5/src/aisc_plugin_interface/cli.py

@@ -0,0 +1,143 @@
+import argparse
+import tomllib
+from pathlib import Path
+from importlib.resources import files
+
+from rich.console import Console
+from rich.prompt import Prompt
+
+console = Console()
+
+
+def _prompt(text, default):
+    return Prompt.ask(f"[bold cyan]{text}[/]", console=console, default=default)
+
+
+def _get_package_name(pyproject: Path):
+    data = tomllib.loads(pyproject.read_text())
+    return data["project"]["name"].replace("-", "_")
+
+
+def _render(template_name: str, context: dict) -> str:
+    template_file = files("aisc_plugin_interface").joinpath("templates", template_name)
+    template = template_file.read_text(encoding="utf-8")
+    for key, value in context.items():
+        template = template.replace(f"{{{{ {key} }}}}", value)
+    return template
+
+
+def _init_or_update_init_file(src_pkg, context) -> bool:
+    init_file = src_pkg / "__init__.py"
+    init_content = _render("init.py.tpl", context)
+
+    if init_file.exists():
+        existing = init_file.read_text(encoding="utf-8")
+
+        # check if import line already exists
+        import_line = f"from .{context['import_path']} import {context['plugin_name']}"
+        if import_line not in existing:
+            # append the new import
+            existing = f"{import_line}\n" + existing.rstrip()
+        else:
+            console.print(
+                f"[red]❌ Import already in {str(init_file)}: '{import_line}'[/]"
+            )
+            return False
+
+        # update __all__
+        if "__all__" in existing:
+            # find current __all__ list and append the class
+            import re
+
+            pattern = r"__all__\s*=\s*\[([^\]]*)\]"
+            match = re.search(pattern, existing)
+            if match:
+                classes = match.group(1).split(",")
+                classes = [c.strip(" '\"") for c in classes]
+                if context["plugin_name"] not in classes:
+                    classes.append(context["plugin_name"])
+                else:
+                    console.print(
+                        f"[red]❌ A plugin with the same name '{context['plugin_name']}' "
+                        "already exists. Abording.[/]"
+                    )
+                    return False
+
+                new_all = ", ".join(f'"{c}"' for c in classes)
+                existing = re.sub(pattern, f"__all__ = [{new_all}]", existing)
+        else:
+            # __all__ does not exist, create it
+            existing += f"\n__all__ = ['{context['plugin_name']}']\n"
+
+        init_file.write_text(existing, encoding="utf-8")
+        console.print(f"[green]✅ Updated __init__.py with {context['plugin_name']}[/]")
+    else:
+        # __init__.py does not exist, create it from template
+        init_file.write_text(init_content, encoding="utf-8")
+        console.print(f"[green]✅ Created __init__.py with {context['plugin_name']}[/]")
+
+    return True
+
+
+def init_plugin(force=False):
+    root = Path.cwd()
+    pyproject = root / "pyproject.toml"
+
+    if not pyproject.exists():
+        console.print("[red]❌ No pyproject.toml found. Run inside a project.[/]")
+        return
+
+    package_name = _get_package_name(pyproject)
+    src_pkg = root / "src" / package_name
+
+    plugin_name = _prompt("Plugin class name", "Plugin")
+    plugin_path_input = _prompt(
+        "Plugin path (path/to/file, .py added automatically if omitted)", "plugin"
+    )
+
+    # remove .py if user included it
+    if plugin_path_input.endswith(".py"):
+        plugin_path_input = plugin_path_input[:-3]
+
+    parts = [p for p in plugin_path_input.strip("/").split("/") if p]
+
+    plugin_dir = src_pkg.joinpath(*parts[:-1]) if len(parts) > 1 else src_pkg
+    plugin_dir.mkdir(parents=True, exist_ok=True)
+
+    plugin_file = plugin_dir / f"{parts[-1]}.py"
+    import_path = ".".join(parts)
+
+    context = {
+        "import_path": import_path,
+        "package_name": package_name,
+        "plugin_name": plugin_name,
+    }
+
+    if not plugin_file.exists() or force:
+        is_valid_name_and_dest = _init_or_update_init_file(src_pkg, context)
+        if is_valid_name_and_dest:
+            plugin_file.write_text(_render("plugin.py.tpl", context))
+            console.print(
+                f"[green]✅ Plugin class '{plugin_name}' template written to file {plugin_file}[/]"
+            )
+
+            console.print(
+                f"[bold magenta]🎉 Plugin '{plugin_name}' has been successfully initialized![/]"
+            )
+    else:
+        console.print(f"[red]❌ File already exists: '{plugin_file}'.[/]")
+
+
+def main():
+    parser = argparse.ArgumentParser(prog="parent-package")
+    sub = parser.add_subparsers(dest="command")
+
+    init_cmd = sub.add_parser("init-plugin")
+    init_cmd.add_argument("--force", action="store_true")
+
+    args = parser.parse_args()
+
+    if args.command == "init-plugin":
+        init_plugin(force=args.force)
+    else:
+        parser.print_help()

aisc_plugin_interface-0.2.5/src/aisc_plugin_interface/decorators/evaluation_input.py

@@ -0,0 +1,24 @@
+from typing import Type
+from aisc_plugin_interface.input_providers.base_input_provider import BaseInputProvider
+from aisc_plugin_interface.models.evaluation_input import InputDefinition, InputType
+
+
+def evaluation_input(name: str, label: str, input_provider_class: Type[BaseInputProvider], input_type: InputType, required: bool = True):
+    """
+    Decorator to create input definitions and their provider.
+    """
+
+    def decorator(cls):
+        if "_input_definitions" not in cls.__dict__:
+            cls._input_definitions = []
+        if "_input_provider_types" not in cls.__dict__:
+            cls._input_provider_types = {}
+
+        if not any(d.name == name for d in cls._input_definitions):
+            cls._input_definitions.append(
+                InputDefinition(name=name, label=label, input_type=input_type, required=required)
+            )
+        cls._input_provider_types[name] = input_provider_class
+        return cls
+
+    return decorator

aisc_plugin_interface-0.2.5/src/aisc_plugin_interface/decorators/metric.py

@@ -0,0 +1,12 @@
+from typing import Callable
+
+
+def metric(name: str):
+    """
+    Decorator to mark a method as a metric exporter.
+    Methods decorated with this should return a list of Measure objects.
+    """
+    def decorator(func: Callable):
+        func.metric_name = name
+        return func
+    return decorator

aisc_plugin_interface-0.2.5/src/aisc_plugin_interface/input_providers/base_input_provider.py

@@ -0,0 +1,31 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class BaseInputProvider(ABC):
+    """
+    Abstract base class for data loaders used by plugins.
+    Input providers handle the transformation of raw bytes (from S3/Storage)
+    into a structured format that the plugin can process.
+    """
+
+    def __init__(self, file_content: bytes):
+        """
+        Initializes the provider and triggers the data reading process.
+        :param file_content: Raw bytes of the file to be processed.
+        """
+        self._data = self._read_data(file_content)
+
+    @abstractmethod
+    def _read_data(self, file_content: bytes) -> Any:
+        """
+        Parses raw bytes into an object (e.g., list, dict, DataFrame, ONNX session etc).
+        Must be implemented by subclasses.
+        """
+        raise NotImplementedError
+
+    def get_data(self) -> Any:
+        """
+        Returns the parsed data stored in the provider.
+        """
+        return self._data

aisc_plugin_interface-0.2.5/src/aisc_plugin_interface/input_providers/csv_input_provider.py

@@ -0,0 +1,20 @@
+import csv
+import io
+
+from .base_input_provider import BaseInputProvider
+
+
+class CsvInputProvider(BaseInputProvider):
+    """
+    A concrete implementation of BaseInputProvider for CSV files.
+    Parses the file content into a list of dictionaries, where each dict represents a row.
+    """
+
+    def _read_data(self, file_content) -> list[dict]:
+        """
+        Converts CSV bytes into a list of dictionaries.
+        """
+        file_stream = io.BytesIO(file_content)
+        wrapper = io.TextIOWrapper(file_stream, encoding='utf-8')
+        reader = csv.DictReader(wrapper)
+        return list(reader)

aisc_plugin_interface-0.2.5/src/aisc_plugin_interface/models/evaluation_input.py

@@ -0,0 +1,14 @@
+import enum
+
+from pydantic import BaseModel
+
+class InputType(str, enum.Enum):
+    MODEL = "model"
+    DATASET = "dataset"
+
+
+class InputDefinition(BaseModel):
+    name: str
+    label: str
+    input_type: InputType
+    required: bool = True

aisc_plugin_interface-0.2.5/src/aisc_plugin_interface/models/measure.py

@@ -0,0 +1,30 @@
+from datetime import datetime
+import enum
+
+from pydantic import BaseModel
+
+
+class Measure(BaseModel):
+    name: str
+    description: str | None = None
+    unit: str | None = None
+    score: float
+    time: datetime = datetime.now()
+    error: str | None = None
+    dimensions: dict[str, str | int | bool] | None = None
+
+
+class ChartType(str, enum.Enum):
+    TABLE = "table"
+    LINE = "line"
+    RADAR = "radar"
+    SCATTER = "scatter"
+    KDE = "kde"
+    BARS = "bars"
+    PIE = "pie"
+    CSV = "csv"
+
+
+class MetricVisualization(BaseModel):
+    chart_type: ChartType
+    metrics: list[str]

aisc_plugin_interface-0.2.5/src/aisc_plugin_interface/models/task.py

@@ -0,0 +1,8 @@
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class TaskProgress(BaseModel):
+    progress: float = Field(..., ge=0.0, le=1.0, description="Progress between 0 and 1")
+    extra: dict[str, Any] = Field(default_factory=dict, description="Plugin-defined extra data")

aisc_plugin_interface-0.2.5/src/aisc_plugin_interface/utils.py

@@ -0,0 +1,43 @@
+class classproperty:
+    """
+    Descriptor for creating a class-level property.
+
+    Allows the definition of a property on a class, similar to @property for instances,
+    so the property can be accessed as `ClassName.attribute` rather than `instance.attribute`.
+
+    Example:
+        class ExampleClass:
+            _value = 123
+
+            @classproperty
+            def value(cls):
+                return cls._value
+
+        print(ExampleClass.value)  # Output: 123
+
+    Parameters:
+        func (function): A callable that accepts the class as an argument and returns a value.
+    """
+
+    def __init__(self, func):
+        """
+        Initializes the descriptor with the getter function.
+
+        Parameters:
+            func (function): Function taking the class as an argument.
+        """
+        self.func = func
+
+    def __get__(self, instance, owner):
+        """
+        Retrieves the class-level property.
+
+        Parameters:
+            instance (object): The instance accessing the attribute
+                               (None when accessed via the class).
+            owner (type): The class on which the property was accessed.
+
+        Returns:
+            Any: The result of invoking the getter function with the class as an argument.
+        """
+        return self.func(owner)