flamapy-fw 2.6.0.dev11__tar.gz → 2.9.0.dev0__tar.gz

{flamapy_fw-2.6.0.dev11/flamapy_fw.egg-info → flamapy_fw-2.9.0.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flamapy-fw
-Version: 2.6.0.dev11
+Version: 2.9.0.dev0
 Summary: Flamapy is a Python-based AAFM framework that takes into consideration previous AAFM tool designs and enables multi-solver and multi-metamodel support for the integration of AAFM tooling on the Python ecosystem.
 Author-email: Flamapy <flamapy@us.es>
 License-Expression: GPL-3.0-or-later

flamapy_fw-2.9.0.dev0/flamapy/core/cache.py

@@ -0,0 +1,141 @@
+"""Compilation-artifact cache: compile once, reuse across operations and sessions.
+
+Opt-in in 2.9: nothing is written unless ``FLAMAPY_CACHE=1`` (3.0 flips this to an opt-out
+``FLAMAPY_NO_CACHE``). Cache directory precedence: ``FLAMAPY_CACHE_DIR`` >
+``$XDG_CACHE_HOME/flamapy`` > ``~/.flamapy/cache``. Artifacts are keyed by the model's
+canonical hash, the target extension, the transformation's options and format version, and
+the plugin version — and stored under ``<hash16>-<extension>-<digest>.<suffix>`` so
+availability by (model, extension) is a glob away (the planner's ``artifact_available``
+hook). Writes are atomic (``os.replace``); the cache is pruned LRU to
+``FLAMAPY_CACHE_MAX_MB`` (default 500). A corrupt artifact is never fatal: loads fall back
+to recomputation.
+"""
+import hashlib
+import logging
+import os
+import tempfile
+from pathlib import Path
+from typing import Any, Optional
+
+LOGGER = logging.getLogger('flamapy.cache')
+
+DEFAULT_MAX_MB = 500
+
+
+def enabled() -> bool:
+    return os.environ.get('FLAMAPY_CACHE') == '1'
+
+
+def directory() -> Path:
+    explicit = os.environ.get('FLAMAPY_CACHE_DIR')
+    if explicit:
+        return Path(explicit)
+    xdg = os.environ.get('XDG_CACHE_HOME')
+    if xdg:
+        return Path(xdg) / 'flamapy'
+    return Path.home() / '.flamapy' / 'cache'
+
+
+def artifact_key(
+    model_hash: str,
+    target_extension: str,
+    options: dict[str, Any],
+    format_version: int,
+    plugin_version: str,
+) -> str:
+    canonical = '\x1f'.join([
+        model_hash, target_extension,
+        ';'.join(f'{key}={options[key]}' for key in sorted(options)),
+        str(format_version), plugin_version,
+    ])
+    return hashlib.sha256(canonical.encode('utf-8')).hexdigest()[:32]
+
+
+def artifact_path(
+    model_hash: str, target_extension: str, key: str, suffix: str
+) -> Path:
+    return directory() / f'{model_hash[:16]}-{target_extension}-{key}.{suffix}'
+
+
+def lookup(path: Path) -> Optional[Path]:
+    """The artifact path if it exists (touching it for LRU), else None."""
+    if not path.is_file():
+        return None
+    try:
+        path.touch()
+    except OSError:
+        pass
+    return path
+
+
+def store(path: Path, write: Any) -> None:
+    """Atomically create ``path`` by calling ``write(temporary_path)`` and renaming."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    handle, temporary = tempfile.mkstemp(dir=path.parent, suffix='.tmp')
+    os.close(handle)
+    try:
+        write(temporary)
+        os.replace(temporary, path)
+    except Exception:  # pylint: disable=broad-except
+        LOGGER.exception('Could not store cache artifact %s', path)
+        Path(temporary).unlink(missing_ok=True)
+        return
+    prune()
+
+
+def available_for(model_hash: Optional[str], target_extension: str) -> bool:
+    """Whether any artifact exists for (model, extension) — the planner's hook."""
+    if not enabled() or not model_hash or not directory().is_dir():
+        return False
+    pattern = f'{model_hash[:16]}-{target_extension}-*'
+    return any(directory().glob(pattern))
+
+
+def prune(max_mb: Optional[int] = None) -> None:
+    """Drop least-recently-used artifacts until the cache fits the size budget."""
+    if max_mb is None:
+        try:
+            max_mb = int(os.environ.get('FLAMAPY_CACHE_MAX_MB', DEFAULT_MAX_MB))
+        except ValueError:
+            max_mb = DEFAULT_MAX_MB
+    base = directory()
+    if not base.is_dir():
+        return
+    files = [(path, path.stat()) for path in base.iterdir() if path.is_file()]
+    total = sum(stat.st_size for _, stat in files)
+    budget = max_mb * 1024 * 1024
+    if total <= budget:
+        return
+    for path, stat in sorted(files, key=lambda item: item[1].st_mtime):
+        try:
+            path.unlink()
+        except OSError:
+            continue
+        total -= stat.st_size
+        if total <= budget:
+            break
+
+
+def info() -> dict[str, Any]:
+    base = directory()
+    files = [path for path in base.iterdir() if path.is_file()] if base.is_dir() else []
+    return {
+        'enabled': enabled(),
+        'directory': str(base),
+        'artifacts': len(files),
+        'size_mb': round(sum(path.stat().st_size for path in files) / (1024 * 1024), 2),
+    }
+
+
+def clear() -> int:
+    base = directory()
+    removed = 0
+    if base.is_dir():
+        for path in base.iterdir():
+            if path.is_file():
+                try:
+                    path.unlink()
+                    removed += 1
+                except OSError:
+                    continue
+    return removed

{flamapy_fw-2.6.0.dev11 → flamapy_fw-2.9.0.dev0}/flamapy/core/discover.py

@@ -1,9 +1,11 @@
 import inspect
 import logging
+import warnings
 from importlib import import_module
+from importlib.metadata import EntryPoint, entry_points as metadata_entry_points
 from pkgutil import iter_modules
 from types import ModuleType
-from typing import Any, Optional, Protocol, Type, runtime_checkable, cast
+from typing import Any, Iterable, Optional, Protocol, Type, runtime_checkable, cast
 
 from flamapy.core.config import PLUGIN_PATHS
 from flamapy.core.exceptions import OperationNotFound
@@ -22,6 +24,12 @@ from flamapy.metamodels.configuration_metamodel.models.configuration import Conf
 
 LOGGER = logging.getLogger("discover")
 
+# Plugins declare themselves via an entry point in this group whose value is the metamodel
+# package (e.g. ``pysat = "flamapy.metamodels.pysat_metamodel"``). The namespace scan over
+# PLUGIN_PATHS is kept as a fallback for plugins that predate entry points; it will be removed
+# in flamapy 3.0 (breaking removals belong in the major).
+ENTRY_POINT_GROUP = "flamapy.plugins"
+
 
 @runtime_checkable
 class OperationWithConfiguration(Protocol):
@@ -41,10 +49,29 @@ def filter_modules_from_plugin_paths() -> list[ModuleType]:
 
 
 class DiscoverMetamodels:
-    def __init__(self) -> None:
-        self.module_paths = filter_modules_from_plugin_paths()
+    """Discovers installed plugins, preferring ``flamapy.plugins`` entry points.
+
+    Plugins without an entry point are still found through the legacy namespace scan over
+    ``PLUGIN_PATHS`` (with a DeprecationWarning — the scan is removed in flamapy 3.0). Passing
+    ``entry_points`` explicitly takes full control of discovery (no scan), which is how tests
+    inject synthetic plugins.
+    """
+
+    _instance: Optional["DiscoverMetamodels"] = None
+
+    def __init__(self, entry_points: Optional[Iterable[EntryPoint]] = None) -> None:
+        self._injected_entry_points = (
+            list(entry_points) if entry_points is not None else None
+        )
         self.plugins: Plugins = self.discover()
 
+    @classmethod
+    def instance(cls) -> "DiscoverMetamodels":
+        """A process-wide shared instance, avoiding redundant discovery scans."""
+        if cls._instance is None:
+            cls._instance = cls()
+        return cls._instance
+
     def search_classes(self, module: ModuleType) -> list[Any]:
         classes = []
         for _, file_name, ispkg in iter_modules(module.__path__, module.__name__ + "."):
@@ -60,29 +87,65 @@ class DiscoverMetamodels:
 
         return classes
 
+    def _build_plugin(self, module: ModuleType) -> Plugin:
+        plugin = Plugin(module=module)
+        for _, _class in self.search_classes(module):
+            if not _class.__module__.startswith(module.__package__):
+                continue  # Exclude modules not in current package
+            inherit = _class.mro()
+
+            if Operation in inherit:
+                plugin.append_operation(_class)
+            elif Transformation in inherit:
+                plugin.append_transformations(_class)
+            elif VariabilityModel in inherit:
+                plugin.variability_model = _class
+        return plugin
+
     def discover(self) -> Plugins:
         plugins = Plugins()
-        for pkg in self.module_paths:
+        covered_modules: set[str] = set()
+
+        if self._injected_entry_points is not None:
+            found_entry_points: list[EntryPoint] = self._injected_entry_points
+        else:
+            found_entry_points = list(metadata_entry_points(group=ENTRY_POINT_GROUP))
+
+        for entry_point in found_entry_points:
+            try:
+                module = entry_point.load()
+            except Exception:  # pylint: disable=broad-except
+                # The distribution is installed but its package is not importable in this
+                # environment (e.g. a shadowed namespace during another package's test run).
+                LOGGER.exception(
+                    "Could not load plugin entry point %s=%s", entry_point.name,
+                    entry_point.value)
+                continue
+            if module.__name__ in covered_modules:
+                continue
+            covered_modules.add(module.__name__)
+            plugins.append(self._build_plugin(module))
+
+        if self._injected_entry_points is not None:
+            return plugins
+
+        scan_only: list[str] = []
+        for pkg in filter_modules_from_plugin_paths():
             for _, plugin_name, ispkg in iter_modules(pkg.__path__, pkg.__name__ + "."):
-                if not ispkg:
+                if not ispkg or plugin_name in covered_modules:
                     continue
                 module = import_module(plugin_name)
-                plugin = Plugin(module=module)
-
-                classes = self.search_classes(module)
-
-                for _, _class in classes:
-                    if not _class.__module__.startswith(module.__package__):
-                        continue  # Exclude modules not in current package
-                    inherit = _class.mro()
-
-                    if Operation in inherit:
-                        plugin.append_operation(_class)
-                    elif Transformation in inherit:
-                        plugin.append_transformations(_class)
-                    elif VariabilityModel in inherit:
-                        plugin.variability_model = _class
-                plugins.append(plugin)
+                covered_modules.add(plugin_name)
+                plugins.append(self._build_plugin(module))
+                scan_only.append(plugin_name)
+
+        if scan_only:
+            warnings.warn(
+                f"Plugins discovered via the namespace scan without a '{ENTRY_POINT_GROUP}' "
+                f"entry point: {', '.join(sorted(scan_only))}. Declare the entry point in the "
+                "plugin's packaging metadata; the namespace-scan fallback will be removed in "
+                "flamapy 3.0.",
+                DeprecationWarning, stacklevel=2)
         return plugins
 
     def reload(self) -> None:

{flamapy_fw-2.6.0.dev11 → flamapy_fw-2.9.0.dev0}/flamapy/core/exceptions.py

@@ -28,3 +28,11 @@ class DuplicatedFeature(FlamaException):
 
 class ConfigurationNotFound(FlamaException):
     pass
+
+
+class NoCompatibleBackendError(FlamaException):
+    """The planner found no installed plugin able to run an operation on a model."""
+
+
+class OperationTimeout(FlamaException):
+    """An asynchronously executed operation exceeded its wall-clock deadline."""

flamapy_fw-2.9.0.dev0/flamapy/core/execution.py

@@ -0,0 +1,206 @@
+"""Execution helpers: the OperationResult envelope and the async execution engine.
+
+This is the seam where provenance is captured: callers that want the envelope (the CLI's
+``-v`` flag, the benchmark harness, and — from 3.0 — the facade itself) run operations
+through :func:`run_and_wrap` instead of calling ``execute``/``get_result`` directly.
+``Operation.execute/get_result`` are untouched: plugin authors need no migration.
+
+Since 2.9 the module also hosts the additive async API: :class:`ExecutionEngine` runs
+operations on a thread pool (models are not picklable; the SAT/BDD/SMT solvers release
+the GIL inside their C cores) and hands back :class:`Job` objects with timeout and
+cancellation. Cancellation is **cooperative**: operations that implement the
+:class:`Interruptible` protocol check the interrupt event inside their Python loops, but
+a call that is deep inside solver C code cannot be interrupted — the job is abandoned
+(its thread keeps running to completion) and only the result is discarded.
+"""
+import threading
+import time
+from concurrent.futures import Future
+from concurrent.futures import TimeoutError as FutureTimeoutError
+from enum import Enum
+from typing import Any, Callable, Optional, Protocol, runtime_checkable
+
+from flamapy.core.exceptions import OperationTimeout
+from flamapy.core.models import VariabilityModel
+from flamapy.core.operations import Operation
+from flamapy.core.operations.result import OperationResult
+
+
+def run_and_wrap(
+    operation: Operation,
+    model: Optional[VariabilityModel],
+    *,
+    operation_name: Optional[str] = None,
+    plugin: Optional[str] = None,
+    model_hash: Optional[str] = None,
+) -> OperationResult[Any]:
+    """Execute ``operation`` on ``model`` and wrap value + provenance in an envelope.
+
+    ``model_hash`` may be passed pre-computed (the facade memoizes it per model);
+    otherwise it is taken from ``model.canonical_hash()``. ``model`` is None for
+    producer operations, which take no input model.
+    """
+    if model_hash is None and model is not None:
+        model_hash = model.canonical_hash()
+    start = time.perf_counter()
+    operation.execute(model)  # type: ignore[arg-type]
+    wall_time = time.perf_counter() - start
+    return OperationResult(
+        value=operation.get_result(),
+        operation=operation_name or type(operation).__name__,
+        plugin=plugin,
+        backend=model.get_extension() if model is not None else None,
+        exact=getattr(operation, 'exact', True),
+        model_hash=model_hash,
+        wall_time=wall_time,
+    )
+
+
+@runtime_checkable
+class Interruptible(Protocol):
+    """Operations that can be cancelled cooperatively.
+
+    The engine hands the operation an event before executing; long-running Python loops
+    should check ``event.is_set()`` and stop early (returning a partial or empty result).
+    """
+
+    def set_interrupt_event(self, event: threading.Event) -> None:
+        ...  # pylint: disable=unnecessary-ellipsis
+
+
+class JobStatus(str, Enum):
+    PENDING = 'pending'
+    RUNNING = 'running'
+    COMPLETED = 'completed'
+    FAILED = 'failed'
+    CANCELLED = 'cancelled'
+
+
+class Job:
+    """A handle to an asynchronously executing operation."""
+
+    def __init__(self, future: 'Future[OperationResult[Any]]',
+                 interrupt_event: threading.Event,
+                 result_adapter: Optional[Callable[[Any], Any]] = None) -> None:
+        self._future = future
+        self._interrupt_event = interrupt_event
+        self._result_adapter = result_adapter
+
+    @property
+    def status(self) -> JobStatus:
+        if self._future.cancelled() or self._interrupt_event.is_set():
+            return JobStatus.CANCELLED
+        if self._future.done():
+            return JobStatus.FAILED if self._future.exception() else JobStatus.COMPLETED
+        return JobStatus.RUNNING if self._future.running() else JobStatus.PENDING
+
+    @property
+    def cancelled(self) -> bool:
+        return self.status is JobStatus.CANCELLED
+
+    def cancel(self) -> None:
+        """Request cancellation: cooperative for running jobs, immediate for queued ones."""
+        self._interrupt_event.set()
+        self._future.cancel()
+
+    def envelope(self, timeout: Optional[float] = None) -> OperationResult[Any]:
+        """The full OperationResult (blocking). See :meth:`result` for the value only."""
+        try:
+            return self._future.result(timeout)
+        except FutureTimeoutError as error:
+            self.cancel()
+            raise OperationTimeout(
+                f'Operation did not finish within {timeout} seconds '
+                '(cancellation requested; a call inside solver C code cannot be '
+                'interrupted and is abandoned).') from error
+
+    def result(self, timeout: Optional[float] = None) -> Any:
+        """The operation's value, waiting up to ``timeout`` seconds.
+
+        Raises :class:`OperationTimeout` on expiry (after requesting cancellation) and
+        re-raises any exception the operation itself raised.
+        """
+        value = self.envelope(timeout).value
+        return self._result_adapter(value) if self._result_adapter is not None else value
+
+
+class ExecutionEngine:
+    """Runs operations asynchronously on bounded daemon worker threads.
+
+    Daemon threads on purpose: a cancelled job whose operation is stuck inside solver C
+    code is *abandoned* — it must never block interpreter exit (a plain
+    ``ThreadPoolExecutor`` joins its workers at exit, which would hang the process on such
+    a job forever). Abandoned jobs simply die with the process; their results are
+    discarded.
+    """
+
+    def __init__(self, max_workers: Optional[int] = None) -> None:
+        import os  # noqa: PLC0415
+        self._slots = threading.BoundedSemaphore(max_workers or (os.cpu_count() or 4))
+
+    # pylint: disable=too-many-arguments
+    def submit(  # noqa: PLR0913 — keyword-only submission inputs are the documented API
+        self,
+        operation: Operation,
+        model: Optional[VariabilityModel],
+        *,
+        operation_name: Optional[str] = None,
+        plugin: Optional[str] = None,
+        model_hash: Optional[str] = None,
+        result_adapter: Optional[Callable[[Any], Any]] = None,
+    ) -> Job:
+        """Schedule ``operation`` on ``model``; returns immediately with a :class:`Job`."""
+        if isinstance(operation, Interruptible):
+            operation_to_interrupt: Optional[Interruptible] = operation
+        else:
+            operation_to_interrupt = None
+
+        def task(interrupt_event: threading.Event) -> OperationResult[Any]:
+            if operation_to_interrupt is not None:
+                operation_to_interrupt.set_interrupt_event(interrupt_event)
+            return run_and_wrap(operation, model, operation_name=operation_name,
+                                plugin=plugin, model_hash=model_hash)
+
+        return self.submit_call(task, result_adapter=result_adapter)
+
+    def submit_call(
+        self,
+        task: Callable[[threading.Event], OperationResult[Any]],
+        *,
+        result_adapter: Optional[Callable[[Any], Any]] = None,
+    ) -> Job:
+        """Schedule an arbitrary unit of work that produces an envelope; returns a :class:`Job`.
+
+        ``task`` runs on a worker thread and receives the job's interrupt event, so it can
+        do expensive preparation (e.g. transforming a feature model into a solver model)
+        *inside* the job — covered by ``Job.result(timeout)`` — and then hand the event to
+        the :class:`Interruptible` operation it builds before running it.
+        """
+        interrupt_event = threading.Event()
+        future: 'Future[OperationResult[Any]]' = Future()
+
+        def runner() -> None:
+            with self._slots:
+                if not future.set_running_or_notify_cancel():
+                    return  # cancelled while queued
+                try:
+                    future.set_result(task(interrupt_event))
+                except BaseException as error:  # pylint: disable=broad-except
+                    future.set_exception(error)
+
+        threading.Thread(target=runner, daemon=True, name='flamapy-job').start()
+        return Job(future, interrupt_event, result_adapter)
+
+    def shutdown(self, wait: bool = True) -> None:  # pylint: disable=unused-argument
+        """Kept for API symmetry: daemon workers need no explicit shutdown."""
+
+
+_DEFAULT_ENGINE: Optional[ExecutionEngine] = None
+
+
+def default_engine() -> ExecutionEngine:
+    """The process-wide engine used by the facade's async API."""
+    global _DEFAULT_ENGINE  # noqa: PLW0603  pylint: disable=global-statement
+    if _DEFAULT_ENGINE is None:
+        _DEFAULT_ENGINE = ExecutionEngine()
+    return _DEFAULT_ENGINE

flamapy_fw-2.9.0.dev0/flamapy/core/manifest.py

@@ -0,0 +1,110 @@
+"""Plugin capability manifests.
+
+A plugin describes what it can handle by declaring a module attribute ``MANIFEST`` (a
+:class:`PluginManifest`) in its package ``__init__``. Discovery reads it via
+:attr:`flamapy.core.plugins.Plugin.manifest`; plugins without one get a conservative
+synthesized default (BOOLEAN level, exact, default cost), so third-party plugins keep
+working unchanged.
+
+The query planner (:mod:`flamapy.core.planner`) routes on manifests when the caller asks for
+``backend='auto'``; the docs generator and the benchmark calibration read them too.
+
+Costs are estimated milliseconds: the time the operation (or, for ``transformation_cost``,
+building the plugin's model from the feature model) takes on a model of a given size, measured
+on the calibration models (see each plugin's ``__init__``). They only have to be right relative
+to each other: the planner adds the transformation and the operation estimates of each candidate
+and takes the smallest. A constant ``cost`` describes an operation whose time barely depends on
+the model; a ``cost_curve`` gives the estimate per size bin for the ones that do.
+
+A manifest names the run its costs come from in ``calibration``; the planner ranks manifests
+without one (including the synthesized default) after every calibrated candidate, so an
+unmeasured number never looks cheaper than a measured one. ``exact=False`` capabilities are
+only chosen with ``allow_approximate``.
+"""
+from dataclasses import dataclass, field, replace
+from typing import Optional
+
+from flamapy.core.models.language_level import LanguageLevel, MajorLevel
+
+DEFAULT_COST = 100
+DEFAULT_TRANSFORMATION_COST = 100
+
+# ((features, cost), ...) in increasing order of features: the cost applies to models with at
+# most that many features. Beyond the last entry the cost grows in proportion to the size, so a
+# curve measured on small models never makes a larger one look as cheap (the plugin's
+# max_features is the place to stop them altogether).
+CostCurve = tuple[tuple[int, int], ...]
+
+
+def cost_at(curve: CostCurve, n_features: int, default: int) -> int:
+    """The cost of a curve for a model of ``n_features`` features (``default`` when it is empty)."""
+    if not curve:
+        return default
+    for bound, cost in curve:
+        if n_features <= bound:
+            return cost
+    last_bound, last_cost = curve[-1]
+    return -(-last_cost * n_features // max(last_bound, 1))  # ceiling of the linear growth
+
+
+@dataclass(frozen=True)
+class OperationCapability:
+    """How a plugin implements one logical operation (keyed by its facade name)."""
+
+    exact: bool = True                     # False => approximate/estimated results
+    max_features: Optional[int] = None     # practical scale ceiling; None => unbounded
+    cost: int = DEFAULT_COST               # estimated ms when no curve is declared
+    cost_curve: CostCurve = ()             # estimated ms per size bin, see the module docstring
+
+    def cost_at(self, n_features: int) -> int:
+        """The estimated cost of the operation on a model of ``n_features`` features."""
+        return cost_at(self.cost_curve, n_features, self.cost)
+
+
+@dataclass(frozen=True)
+class PluginManifest:
+    name: str
+    extension: Optional[str] = None        # the plugin's model extension, if it has a model
+    supported_level: LanguageLevel = field(
+        default_factory=lambda: LanguageLevel(MajorLevel.BOOLEAN, set()))
+    default_cost: int = DEFAULT_COST
+    # Plugin-wide scale ceiling, applied to every operation that declares none: the right
+    # place for a limit that comes from building the model (e.g. BDD compilation).
+    max_features: Optional[int] = None
+    # Estimated ms to build this plugin's model from the feature model (constant or per size
+    # bin); the planner charges it once per plan unless the model is already built or cached.
+    transformation_cost: int = DEFAULT_TRANSFORMATION_COST
+    transformation_cost_curve: CostCurve = ()
+    # A plugin whose runtime dependency is missing (an external binary, a native package)
+    # declares itself unavailable with the reason; the planner reports it instead of choosing
+    # a backend that would fail.
+    available: bool = True
+    unavailable_reason: str = ''
+    # The calibration run the costs come from (e.g. '2026-11-06'); None for estimates that were
+    # never measured, which the planner ranks after calibrated ones.
+    calibration: Optional[str] = None
+    operations: dict[str, OperationCapability] = field(default_factory=dict)
+
+    def supports(self, model_level: LanguageLevel) -> bool:
+        """Whether a model at ``model_level`` is within this plugin's declared capability."""
+        return (self.supported_level.major.value >= model_level.major.value
+                and model_level.minors <= self.supported_level.minors)
+
+    def capability(self, operation_name: str) -> OperationCapability:
+        """The declared capability for an operation, or a default-cost exact one; the
+        plugin-wide ``max_features`` applies when the operation declares none."""
+        declared = self.operations.get(operation_name)
+        if declared is None:
+            return OperationCapability(cost=self.default_cost, max_features=self.max_features)
+        if declared.max_features is None and self.max_features is not None:
+            return replace(declared, max_features=self.max_features)
+        return declared
+
+    def transformation_cost_at(self, n_features: int) -> int:
+        """The estimated cost of building this plugin's model for ``n_features`` features."""
+        return cost_at(self.transformation_cost_curve, n_features, self.transformation_cost)
+
+
+def synthesized_manifest(name: str, extension: Optional[str] = None) -> PluginManifest:
+    """The conservative default for plugins that declare no MANIFEST."""
+    return PluginManifest(name=name, extension=extension)

flamapy_fw-2.9.0.dev0/flamapy/core/models/__init__.py

@@ -0,0 +1,11 @@
+from .variability_model import VariabilityModel, VariabilityElement  # pylint: disable=cyclic-import
+from .ast import AST, ASTOperation, NodeType  # pylint: disable=cyclic-import
+from .language_level import (  # pylint: disable=cyclic-import
+    ALL_MINOR_LEVELS,
+    LanguageLevel,
+    MajorLevel,
+    MinorLevel,
+)
+
+__all__ = ["ALL_MINOR_LEVELS", "AST", "ASTOperation", "LanguageLevel", "MajorLevel",
+           "MinorLevel", "NodeType", "VariabilityElement", "VariabilityModel"]