flamapy-fw 2.0.0.dev0__tar.gz

flamapy-fw-2.0.0.dev0/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.1
+Name: flamapy-fw
+Version: 2.0.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.
+Home-page: https://github.com/flamapy/core
+Author: Flamapy
+Author-email: flamapy@us.es
+License: UNKNOWN
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+
+# Flamapy
+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.
+
+The main features of the framework are:
+* Easy to extend by enabling the creation of new plugins following a semi-automatic generator approach.
+* Support multiple variability models. Currently, it provides support for cardinality-based feature models. However, it is easy to integrate others such as attributed feature models
+* Support multiple solvers. Currently, it provides support for the PySAT metasolver, which enables more than ten different solvers.
+* Support multiple operations. It is developed, having in mind multi-model operations such as those depicted by Familiar  and single-model operations.
+
+## Available plugins
+[flamapy-fm](https://github.com/flamapy/fm_metamodel)
+[flamapy-sat](https://github.com/flamapy/pysat_metamodel)
+
+## Documentation
+
+All the proyect related documentation can be found in wiki format at [the tool website](https://flamapy.github.io/)
+
+## Changelog
+Detailed changes for each release are documented in the [release notes](https://github.com/diverso-lab/core/releases)
+
+## Contributing
+
+See [CONTRIBUTING.md](https://github.com/diverso-lab/core/blob/master/CONTRIBUTING.md)
+
+

flamapy-fw-2.0.0.dev0/README.md

@@ -0,0 +1,23 @@
+# Flamapy
+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.
+
+The main features of the framework are:
+* Easy to extend by enabling the creation of new plugins following a semi-automatic generator approach.
+* Support multiple variability models. Currently, it provides support for cardinality-based feature models. However, it is easy to integrate others such as attributed feature models
+* Support multiple solvers. Currently, it provides support for the PySAT metasolver, which enables more than ten different solvers.
+* Support multiple operations. It is developed, having in mind multi-model operations such as those depicted by Familiar  and single-model operations.
+
+## Available plugins
+[flamapy-fm](https://github.com/flamapy/fm_metamodel)
+[flamapy-sat](https://github.com/flamapy/pysat_metamodel)
+
+## Documentation
+
+All the proyect related documentation can be found in wiki format at [the tool website](https://flamapy.github.io/)
+
+## Changelog
+Detailed changes for each release are documented in the [release notes](https://github.com/diverso-lab/core/releases)
+
+## Contributing
+
+See [CONTRIBUTING.md](https://github.com/diverso-lab/core/blob/master/CONTRIBUTING.md)

flamapy-fw-2.0.0.dev0/flamapy/commands/__init__.py

@@ -0,0 +1,88 @@
+#!/usr/bin/python
+
+import argparse
+import os
+import sys
+from pathlib import Path
+from shutil import copytree
+
+from hug import development_runner
+
+
+def parser() -> argparse.ArgumentParser:
+    main_parser = argparse.ArgumentParser()
+    subparser = main_parser.add_subparsers(title="commands", dest="command")
+
+    new_plugin = subparser.add_parser("new_plugin", help="new_plugin")
+    new_plugin.add_argument('name', type=str, help='A name for your plugin. Ex: flama')
+    new_plugin.add_argument('extension', type=str, help='A extension for your plugin. Ex: fm')
+    new_plugin.add_argument('--path', default='.', type=str, help='Plugin project path.')
+
+    subparser.add_parser("cli", help="cli", description='flamapy_admin.py api: command line api')
+    return main_parser
+
+
+def cmd_new_plugin(options: argparse.Namespace) -> None:
+    name = options.name
+    ext = options.extension
+    dst = options.path
+    src = 'skel_metamodel/'
+
+    # Check DST exist
+    if not os.path.isdir(dst):
+        print(f"Folder {dst} not exist")
+        sys.exit()
+
+    # Check DST is empty
+    if len(os.listdir(dst)) != 0:
+        print(f"Folder {dst} is not empty")
+        sys.exit()
+
+    # Check DST has permissions to WRITE
+    if not os.access(dst, os.W_OK):
+        print(f"Folder {dst} has not write permissions")
+        sys.exit()
+
+    # Generating structure
+    print("Generating structure ...")
+
+    copy_files = copytree(src, dst, dirs_exist_ok=True)
+
+    for copy_file in Path(copy_files).glob('**/*'):
+        if copy_file.is_dir():
+            continue
+        with open(copy_file, "r", encoding="utf-8") as file:
+            lines = file.readlines()
+        with open(copy_file, "w", encoding="utf-8") as filewrite:
+            for line in lines:
+                out_line = line.replace('__NAME__', name.capitalize()).replace('__EXT__', ext)
+                filewrite.write(out_line)
+
+    os.rename(os.path.join(dst, 'flamapy/metamodels/__NAME__'),
+              os.path.join(dst, f'flamapy/metamodels/{name}'))
+    print("Done!")
+
+
+def cmd_cli() -> None:
+    subcommand = sys.argv[2:]
+    if not subcommand:
+        subcommand = ["help"]
+    sys.argv = [".", "-m", "flamapy.endpoint.diverso_lab", "cli", "-c"] + subcommand
+    development_runner.hug.interface.cli()
+
+
+def flamapy_admin() -> None:
+    main_parser = parser()
+
+    options, _ = main_parser.parse_known_args()
+    command = options.command
+
+    if command is None:
+        main_parser.print_help()
+        sys.exit()
+
+    if command == "new_plugin":
+        cmd_new_plugin(options)
+
+    if command == "cli":
+        cmd_cli()

flamapy-fw-2.0.0.dev0/flamapy/core/config.py

@@ -0,0 +1,3 @@
+PLUGIN_PATHS = [
+    'flamapy.metamodels',
+]

flamapy-fw-2.0.0.dev0/flamapy/core/discover.py

@@ -0,0 +1,320 @@
+import inspect
+import logging
+from importlib import import_module
+from pkgutil import iter_modules
+from types import ModuleType
+from typing import Any, Optional, Protocol, Type, runtime_checkable, cast
+
+from flamapy.core.config import PLUGIN_PATHS
+from flamapy.core.exceptions import OperationNotFound
+from flamapy.core.exceptions import TransformationNotFound
+from flamapy.core.exceptions import ConfigurationNotFound
+from flamapy.core.models import VariabilityModel
+from flamapy.core.operations import Operation
+from flamapy.core.plugins import (
+    Operations,
+    Plugin,
+    Plugins
+)
+from flamapy.core.transformations import Transformation
+from flamapy.core.transformations.text_to_model import TextToModel
+from flamapy.core.transformations.model_to_model import ModelToModel
+from flamapy.metamodels.configuration_metamodel.models.configuration import Configuration
+
+
+LOGGER = logging.getLogger('discover')
+
+
+@runtime_checkable
+class OperationWithConfiguration(Protocol):
+    def set_configuration(self, configuration: Configuration) -> None:
+        pass
+
+
+def filter_modules_from_plugin_paths() -> list[ModuleType]:
+    results: list[ModuleType] = []
+    for path in PLUGIN_PATHS:
+        try:
+            module: ModuleType = import_module(path)
+            results.append(module)
+        except ModuleNotFoundError:
+            LOGGER.exception('ModuleNotFoundError %s', path)
+    return results
+
+
+class DiscoverMetamodels:
+    def __init__(self) -> None:
+        self.module_paths = filter_modules_from_plugin_paths()
+        self.plugins: Plugins = self.discover()
+
+    def search_classes(self, module: ModuleType) -> list[Any]:
+        classes = []
+        for _, file_name, ispkg in iter_modules(
+            module.__path__, module.__name__ + '.'
+        ):
+            if ispkg:
+                classes += self.search_classes(import_module(file_name))
+            else:
+                _file = import_module(file_name)
+                classes += inspect.getmembers(_file, inspect.isclass)
+        return classes
+
+    def discover(self) -> Plugins:
+        plugins = Plugins()
+        for pkg in self.module_paths:
+            for _, plugin_name, ispkg in iter_modules(
+                pkg.__path__, pkg.__name__ + '.'
+            ):
+                if not ispkg:
+                    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)
+        return plugins
+
+    def reload(self) -> None:
+        self.plugins = self.discover()
+
+    def get_operations(self) -> list[Type[Operation]]:
+        """ Get the operations for all modules """
+        operations: list[Type[Operation]] = []
+        for plugin in self.plugins:
+            operations += plugin.operations
+        return operations
+
+    def get_name_operations(self) -> list[str]:
+        operations = []
+        for operation in self.get_operations():
+            operations.append(operation.__name__)
+            base = operation.__base__.__name__
+            if base != 'ABC':
+                operations.append(base)
+
+        return operations
+
+    def get_transformations(self) -> list[Type[Transformation]]:
+        """ Get transformations for all modules """
+        transformations: list[Type[Transformation]] = []
+        for plugin in self.plugins:
+            transformations += plugin.transformations
+        return transformations
+
+    def get_transformations_t2m(self) -> list[Type[TextToModel]]:
+        """ Get t2m transformations for all modules """
+
+        transformations: list[Type[TextToModel]] = []
+        for plugin in self.plugins:
+            transformations += [
+                t for t in plugin.transformations if issubclass(t, TextToModel)
+            ]
+        return transformations
+
+    def get_transformations_m2m(self) -> list[Type[ModelToModel]]:
+        """ Get m2m transformations for all modules """
+
+        transformations: list[Type[ModelToModel]] = []
+        for plugin in self.plugins:
+            transformations += [
+                t for t in plugin.transformations if issubclass(t, ModelToModel)
+            ]
+        return transformations
+
+    def get_operations_by_plugin(self, plugin_name: str) -> Operations:
+        return self.plugins.get_operations_by_plugin_name(plugin_name)
+
+    def get_plugins_with_operation(self, operation_name: str) -> list[Plugin]:
+        return [
+            plugin for plugin in self.plugins
+            if operation_name in self.get_name_operations_by_plugin(plugin.name)
+        ]
+
+    def get_name_operations_by_plugin(self, plugin_name: str) -> list[str]:
+        operations = []
+        for operation in self.get_operations_by_plugin(plugin_name):
+            operations.append(operation.__name__)
+            base = operation.__base__.__name__
+            if base != 'ABC':
+                operations.append(base)
+
+        return operations
+
+    def get_variability_models(self) -> list[VariabilityModel]:
+        return self.plugins.get_variability_models()
+
+    def get_plugins(self) -> list[str]:
+        return self.plugins.get_plugin_names()
+
+    def use_transformation_m2t(self, src: VariabilityModel, dst: str) -> str:
+        plugin = self.plugins.get_plugin_by_variability_model(src)
+        return plugin.use_transformation_m2t(src, dst)
+
+    def use_transformation_t2m(self, src: str, dst: str) -> VariabilityModel:
+        plugin = self.plugins.get_plugin_by_extension(dst)
+        return plugin.use_transformation_t2m(src)
+
+    def use_transformation_m2m(self, src: VariabilityModel, dst: str) -> VariabilityModel:
+        plugin = self.plugins.get_plugin_by_extension(dst)
+        return plugin.use_transformation_m2m(src, dst)
+
+    def get_operation(self, src: VariabilityModel, operation_name: str) -> Operation:
+        plugin = self.plugins.get_plugin_by_variability_model(src)
+        return plugin.get_operation(operation_name)
+
+    def use_operation(self, src: VariabilityModel, operation_name: str) -> Operation:
+        plugin = self.plugins.get_plugin_by_variability_model(src)
+        operation = plugin.get_operation(operation_name)
+        return plugin.use_operation(operation, src)
+
+    def use_operation_from_vm(
+        self,
+        operation_name: str,
+        vm_orig: VariabilityModel,
+        plugin_name: Optional[str] = None,
+        configuration_file: Optional[str] = None
+    ) -> Any:
+
+        if operation_name not in self.get_name_operations():
+            raise OperationNotFound()
+
+        if plugin_name is not None:
+            plugin = self.plugins.get_plugin_by_name(plugin_name)
+            #vm_temp = plugin.use_transformation_t2m(file)
+        else:
+            #vm_temp = self.__transform_to_model_from_file(file)
+            plugin = self.plugins.get_plugin_by_extension(
+                vm_orig.get_extension())
+
+            if operation_name not in self.get_name_operations_by_plugin(plugin.name):
+                transformation_way = self.__search_transformation_way(
+                    plugin, operation_name)
+
+                for (_, dst) in transformation_way:
+                    _plugin = self.plugins.get_plugin_by_extension(dst)
+                    vm_temp = _plugin.use_transformation_m2m(vm_temp, dst)
+                    plugin = _plugin
+
+        operation = plugin.get_operation(operation_name)
+        if isinstance(operation, OperationWithConfiguration):
+            if configuration_file is None:
+                raise ConfigurationNotFound()
+            configuration = self.__transform_to_model_from_file(configuration_file)
+            operation.set_configuration(cast(Configuration, configuration))
+
+        operation = plugin.use_operation(operation, vm_temp)
+
+        return operation.get_result()
+
+    def use_operation_from_file(
+        self,
+        operation_name: str,
+        file: str,
+        plugin_name: Optional[str] = None,
+        configuration_file: Optional[str] = None
+    ) -> Any:
+
+        if operation_name not in self.get_name_operations():
+            raise OperationNotFound()
+
+        if plugin_name is not None:
+            plugin = self.plugins.get_plugin_by_name(plugin_name)
+            vm_temp = plugin.use_transformation_t2m(file)
+        else:
+            vm_temp = self.__transform_to_model_from_file(file)
+            plugin = self.plugins.get_plugin_by_extension(
+                vm_temp.get_extension())
+
+            if operation_name not in self.get_name_operations_by_plugin(plugin.name):
+                transformation_way = self.__search_transformation_way(
+                    plugin, operation_name)
+
+                for (_, dst) in transformation_way:
+                    _plugin = self.plugins.get_plugin_by_extension(dst)
+                    vm_temp = _plugin.use_transformation_m2m(vm_temp, dst)
+                    plugin = _plugin
+
+        operation = plugin.get_operation(operation_name)
+        if isinstance(operation, OperationWithConfiguration):
+            if configuration_file is None:
+                raise ConfigurationNotFound()
+            configuration = self.__transform_to_model_from_file(configuration_file)
+            operation.set_configuration(cast(Configuration, configuration))
+
+        operation = plugin.use_operation(operation, vm_temp)
+        return operation.get_result()
+
+    def __transform_to_model_from_file(self, file: str) -> VariabilityModel:
+        t2m_transformations = self.get_transformations_t2m()
+        extension = file.split('.')[-1]
+        t2m_filters = filter(
+            lambda t2m: t2m.get_source_extension() == extension,
+            t2m_transformations
+        )
+
+        t2m = next(t2m_filters, None)
+        if t2m is None:
+            raise TransformationNotFound()
+
+        return t2m(file).transform()
+
+    def __search_transformation_way(
+        self,
+        plugin: Plugin,
+        operation_name: str
+    ) -> list[tuple[str, str]]:
+        '''
+        Search way to reach plugin with operation_name using m2m transformations
+        '''
+        way: list[tuple[str, str]] = []
+
+        plugins_with_operation = self.get_plugins_with_operation(
+            operation_name)
+        m2m_transformations = self.get_transformations_m2m()
+
+        input_extension = plugin.get_extension()
+
+        def __search_recursive_way(
+            input_extension: str,
+            output_extension: str,
+            tmp_way: list[tuple[str, str]]
+        ) -> list[tuple[str, str]]:
+
+            for m2m in m2m_transformations:
+                in_m2m = m2m.get_source_extension()
+                out_m2m = m2m.get_destination_extension()
+
+                if out_m2m == output_extension:
+                    _next = (in_m2m, out_m2m)
+
+                    if _next in tmp_way:
+                        continue
+
+                    tmp_way.insert(0, _next)
+
+                    if input_extension == in_m2m:
+                        return tmp_way
+
+                    return __search_recursive_way(input_extension, in_m2m, tmp_way)
+
+            return tmp_way
+
+        for _plugin in plugins_with_operation:
+            output_extension = _plugin.get_extension()
+            way = __search_recursive_way(input_extension, output_extension, [])
+            if way and output_extension == way[-1][1]:
+                return way
+
+        raise NotImplementedError('Way to execute operation not found')

flamapy-fw-2.0.0.dev0/flamapy/core/exceptions.py

@@ -0,0 +1,30 @@
+class FlamaException(Exception):
+    pass
+
+
+class ParsingException(Exception):
+    pass
+
+
+class PluginNotFound(FlamaException):
+    pass
+
+
+class OperationNotFound(FlamaException):
+    pass
+
+
+class TransformationNotFound(FlamaException):
+    pass
+
+
+class ElementNotFound(FlamaException):
+    pass
+
+
+class DuplicatedFeature(FlamaException):
+    pass
+
+
+class ConfigurationNotFound(FlamaException):
+    pass

flamapy-fw-2.0.0.dev0/flamapy/core/models/__init__.py

@@ -0,0 +1,4 @@
+from .variability_model import VariabilityModel, VariabilityElement  # pylint: disable=cyclic-import
+from .ast import AST, ASTOperation  # pylint: disable=cyclic-import
+
+__all__ = ["VariabilityModel",  "AST", "VariabilityElement", "ASTOperation"]