flamapy-rest 2.6.0.dev2__py3-none-any.whl → 2.6.0.dev6__py3-none-any.whl

flamapy/interfaces/rest/config.py

@@ -0,0 +1,36 @@
+import os
+from typing import Any
+
+
+def _env_bool(name: str, default: bool) -> bool:
+    raw = os.environ.get(name)
+    if raw is None:
+        return default
+    return raw.strip().lower() in ('1', 'true', 'yes', 'on')
+
+
+def _env_int(name: str, default: int) -> int:
+    raw = os.environ.get(name)
+    if raw is None or raw.strip() == '':
+        return default
+    return int(raw)
+
+
+def load_config() -> dict[str, Any]:
+    """Abuse-control settings, every one overridable through an env var so the
+    Docker image stays a single self-contained container."""
+    return {
+        'MAX_CONTENT_LENGTH': _env_int('FLAMAPY_MAX_CONTENT_LENGTH', 16 * 1024 * 1024),
+        'RATELIMIT_ENABLED': _env_bool('FLAMAPY_RATELIMIT_ENABLED', True),
+        'RATELIMIT_STORAGE_URI': os.environ.get('FLAMAPY_RATELIMIT_STORAGE_URI', 'memory://'),
+        'RATELIMIT_DEFAULT_OPERATION': os.environ.get(
+            'FLAMAPY_RATELIMIT_DEFAULT', '60 per minute'
+        ),
+        'RATELIMIT_EXPENSIVE_OPERATION': os.environ.get(
+            'FLAMAPY_RATELIMIT_EXPENSIVE', '10 per minute'
+        ),
+        'OPERATION_TIMEOUT': _env_int('FLAMAPY_OPERATION_TIMEOUT', 60),
+        'CACHE_TTL': _env_int('FLAMAPY_CACHE_TTL', 3600),
+        'CACHE_MAXSIZE': _env_int('FLAMAPY_CACHE_MAXSIZE', 128),
+        'TRUST_PROXY': _env_bool('FLAMAPY_TRUST_PROXY', False),
+    }

flamapy/interfaces/rest/extensions.py

@@ -0,0 +1,52 @@
+import threading
+from typing import Any, Optional
+
+from cachetools import TTLCache
+from flask import Flask, current_app
+from flask_limiter import Limiter
+from flask_limiter.util import get_remote_address
+
+
+def default_operation_limit() -> str:
+    return current_app.config['RATELIMIT_DEFAULT_OPERATION']
+
+
+def expensive_operation_limit() -> str:
+    return current_app.config['RATELIMIT_EXPENSIVE_OPERATION']
+
+
+# Storage URI and enabled flag are picked up from app.config (RATELIMIT_*)
+# during init_app; per-route limits are attached in operations_routes.
+limiter = Limiter(key_func=get_remote_address)
+
+
+class ResultCache:
+    """Per-process TTL cache for operation results. The cache object is created
+    on init_app so its size/TTL follow the app configuration; a TTL of 0
+    disables caching entirely."""
+
+    def __init__(self) -> None:
+        self._cache: Optional[TTLCache[str, Any]] = None
+        self._lock = threading.Lock()
+
+    def init_app(self, app: Flask) -> None:
+        ttl = app.config['CACHE_TTL']
+        if ttl > 0:
+            self._cache = TTLCache(maxsize=app.config['CACHE_MAXSIZE'], ttl=ttl)
+        else:
+            self._cache = None
+
+    def get(self, key: str) -> Any:
+        if self._cache is None:
+            return None
+        with self._lock:
+            return self._cache.get(key)
+
+    def set(self, key: str, value: Any) -> None:
+        if self._cache is None:
+            return
+        with self._lock:
+            self._cache[key] = value
+
+
+result_cache = ResultCache()

flamapy/interfaces/rest/operations_routes.py

@@ -1,4 +1,5 @@
 import os
+import hashlib
 import inspect
 import json
 import shutil
@@ -6,16 +7,40 @@ import tempfile
 import typing
 from typing import Any, Callable
 
-from flask import Blueprint, request, jsonify, abort
+from flask import Blueprint, Response, current_app, request, jsonify, abort
 from werkzeug.datastructures import FileStorage
 from werkzeug.utils import secure_filename
 from flamapy.interfaces.python.flamapy_feature_model import FLAMAFeatureModel, Backend
-from flamapy.core.exceptions import FlamaException
 from flamapy.metamodels.configuration_metamodel.models import Configuration
 
+from flamapy.interfaces.rest.extensions import (
+    limiter,
+    result_cache,
+    default_operation_limit,
+    expensive_operation_limit,
+)
+from flamapy.interfaces.rest.runner import ModelParseError, OperationTimeout, run_operation
+
 
 operations_bp = Blueprint('operations_bp', __name__, url_prefix='/api/v1/operations')
 
+# Operations that enumerate or repeatedly invoke a solver; they get the stricter
+# rate-limit tier because a single call can monopolize a CPU for a long time.
+_EXPENSIVE_OPERATIONS = {
+    'configurations',
+    'configurations_number',
+    'configurations_with_n_features',
+    'conflict',
+    'diagnosis',
+    'feature_inclusion_probability',
+    'homogeneity',
+    'product_distribution',
+    'sampling',
+    'unique_features',
+    'variability',
+    'variant_features',
+}
+
 # Backward-compatible multipart field names for parameters that the API exposed
 # before the dispatcher became generic. Any other parameter derives its field
 # name from the parameter itself (file params drop the trailing "_path").
@@ -116,6 +141,26 @@ def _resolve_kwargs(operation: Any, work_dir: str) -> dict[str, Any]:
     return kwargs
 
 
+def _cache_key(
+    operation_name: str, operation: Any, model_path: str, kwargs: dict[str, Any]
+) -> str:
+    """Digest of everything that determines the result: the operation, the model
+    contents and every argument (file arguments by content, not by temp path)."""
+    file_params = {p.name for p in _operation_params(operation) if _is_file_param(p)}
+    digest = hashlib.sha256()
+    digest.update(operation_name.encode())
+    with open(model_path, 'rb') as model_file:
+        digest.update(model_file.read())
+    for name in sorted(kwargs):
+        digest.update(b'\x00' + name.encode() + b'\x00')
+        if name in file_params:
+            with open(kwargs[name], 'rb') as uploaded_file:
+                digest.update(uploaded_file.read())
+        else:
+            digest.update(repr(kwargs[name]).encode())
+    return digest.hexdigest()
+
+
 def _api_call(operation_name: str) -> Any:
     uploaded_model = request.files.get('model')
     if uploaded_model is None or not uploaded_model.filename:
@@ -126,19 +171,34 @@ def _api_call(operation_name: str) -> Any:
     work_dir = tempfile.mkdtemp(prefix='flamapy_')
     try:
         model_path = _save_upload(uploaded_model, work_dir)
+        operation = getattr(FLAMAFeatureModel, operation_name)
+        kwargs = _resolve_kwargs(operation, work_dir)
+
+        key = _cache_key(operation_name, operation, model_path, kwargs)
+        payload = result_cache.get(key)
+        if payload is not None:
+            response: Response = jsonify(payload)
+            response.headers['X-Cache'] = 'HIT'
+            return response
+
         try:
-            fm = FLAMAFeatureModel(model_path)
-        except FlamaException:
+            result = run_operation(
+                model_path, operation_name, kwargs, current_app.config['OPERATION_TIMEOUT']
+            )
+        except ModelParseError:
             abort(400, "The uploaded model could not be parsed")
-        operation = getattr(fm, operation_name)
-        kwargs = _resolve_kwargs(operation, work_dir)
-        result = operation(**kwargs)
+        except OperationTimeout as exc:
+            abort(504, str(exc))
     finally:
         shutil.rmtree(work_dir, ignore_errors=True)
 
     if result is None:
         return jsonify(error='Not valid result'), 404
-    return jsonify(json.loads(json.dumps(result, cls=CustomJSONEncoder)))
+    payload = json.loads(json.dumps(result, cls=CustomJSONEncoder))
+    result_cache.set(key, payload)
+    response = jsonify(payload)
+    response.headers['X-Cache'] = 'MISS'
+    return response
 
 
 def extract_docstring_with_swagger_info(method: Any) -> str:
@@ -189,9 +249,12 @@ def create_route(operation_name: str, docstring: str) -> Callable[[], Any]:
 
 
 # Introspect FLAMAFeatureModel to expose every public method as a POST route,
-# generating its Swagger spec from the method signature.
+# generating its Swagger spec from the method signature. Limits are passed as
+# callables so they read the app config of whichever app the blueprint joins.
 for name, method in inspect.getmembers(FLAMAFeatureModel, predicate=inspect.isfunction):
     if name.startswith('_'):
         continue
     docstring = extract_docstring_with_swagger_info(method)
-    operations_bp.route(f'/{name}', methods=['POST'])(create_route(name, docstring))
+    limit = expensive_operation_limit if name in _EXPENSIVE_OPERATIONS else default_operation_limit
+    route_view = limiter.limit(limit)(create_route(name, docstring))
+    operations_bp.route(f'/{name}', methods=['POST'])(route_view)

flamapy/interfaces/rest/runner.py

@@ -0,0 +1,70 @@
+import multiprocessing
+from typing import Any
+
+from flamapy.core.exceptions import FlamaException
+from flamapy.interfaces.python.flamapy_feature_model import FLAMAFeatureModel
+
+
+class OperationTimeout(Exception):
+    """The operation exceeded the configured time budget and was killed."""
+
+
+class ModelParseError(Exception):
+    """The uploaded model could not be parsed."""
+
+
+def _execute(model_path: str, operation_name: str, kwargs: dict[str, Any]) -> Any:
+    try:
+        feature_model = FLAMAFeatureModel(model_path)
+    except FlamaException as exc:
+        raise ModelParseError(str(exc)) from exc
+    return getattr(feature_model, operation_name)(**kwargs)
+
+
+def _child(conn: Any, model_path: str, operation_name: str, kwargs: dict[str, Any]) -> None:
+    try:
+        conn.send(('ok', _execute(model_path, operation_name, kwargs)))
+    except ModelParseError as exc:
+        conn.send(('parse_error', str(exc)))
+    except Exception as exc:  # pylint: disable=broad-except
+        conn.send(('error', str(exc)))
+    finally:
+        conn.close()
+
+
+def run_operation(
+    model_path: str, operation_name: str, kwargs: dict[str, Any], timeout: int
+) -> Any:
+    """Run parse + operation, enforcing ``timeout`` seconds by executing in a
+    forked child process — solver code is CPU-bound C that threads or signals
+    cannot reliably interrupt, but a child process can always be killed.
+
+    A timeout of 0 disables the budget and runs the operation inline.
+    """
+    if timeout <= 0:
+        return _execute(model_path, operation_name, kwargs)
+
+    ctx = multiprocessing.get_context('fork')
+    parent_conn, child_conn = ctx.Pipe(duplex=False)
+    process = ctx.Process(
+        target=_child, args=(child_conn, model_path, operation_name, kwargs)
+    )
+    process.start()
+    child_conn.close()
+    try:
+        if not parent_conn.poll(timeout):
+            raise OperationTimeout(
+                f"Operation '{operation_name}' exceeded the {timeout}s time limit"
+            )
+        status, payload = parent_conn.recv()
+    finally:
+        if process.is_alive():
+            process.terminate()
+        process.join()
+        parent_conn.close()
+
+    if status == 'parse_error':
+        raise ModelParseError(payload)
+    if status == 'error':
+        raise FlamaException(payload)
+    return payload

flamapy_rest-2.6.0.dev6.dist-info/METADATA

@@ -0,0 +1,218 @@
+Metadata-Version: 2.4
+Name: flamapy-rest
+Version: 2.6.0.dev6
+Summary: Flamapy feature model is a distribution of the flama framework containing all plugins required to analyze feature models. It also offers a richer API and a complete command line interface and documentation.
+Author-email: Flamapy <flamapy@us.es>
+License-Expression: GPL-3.0-or-later
+Project-URL: Homepage, https://github.com/flamapy/flamapy-rest
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: Flask
+Requires-Dist: gunicorn
+Requires-Dist: flamapy~=2.6.0.dev5
+Requires-Dist: flask-swagger-ui
+Requires-Dist: flask-restplus
+Requires-Dist: flask_cors
+Requires-Dist: flasgger
+Requires-Dist: Flask-Limiter
+Requires-Dist: cachetools
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-mock; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: coverage; extra == "dev"
+
+<div align="center">
+
+  <a href="https://github.com/flamapy/flamapy-rest/actions/workflows/main.yml">![Python analysis](https://github.com/flamapy/flamapy-rest/actions/workflows/main.yml/badge.svg?branch=main)</a>
+  <a href="https://github.com/flamapy/flamapy-rest/actions/workflows/conventionalpr.yml">![Conventional Commits](https://github.com/flamapy/flamapy-rest/actions/workflows/conventionalpr.yml/badge.svg?branch=main)</a>
+  <a href="https://github.com/flamapy/flamapy-rest/actions/workflows/docker-image.yml">![Docker Image CI](https://github.com/flamapy/flamapy-rest/actions/workflows/docker-image.yml/badge.svg)</a>
+  <a href="https://pypi.org/project/flamapy-rest/">![PyPI](https://img.shields.io/pypi/v/flamapy-rest?label=pypi%20package)</a>
+  <a href="https://hub.docker.com/r/flamapy/flamapy-rest">![Docker Pulls](https://img.shields.io/docker/pulls/flamapy/flamapy-rest)</a>
+  <a href="https://pypi.org/project/flamapy-rest/">![PyPI - Downloads](https://img.shields.io/pypi/dm/flamapy-rest)</a>
+</div>
+
+<div id="top"></div>
+<br />
+<div align="center">
+
+  <h3 align="center">FLAMAPY REST API</h3>
+
+  <p align="center">
+    A new and easy way to use FLAMA
+    <br />
+    <a href="https://github.com/flamapy/flamapy-rest/issues">Report Bug</a>
+    ·
+    <a href="https://github.com/flamapy/flamapy-rest/issues">Request Feature</a>
+  </p>
+</div>
+
+<!-- ABOUT THE PROJECT -->
+## About The Project
+
+`flamapy-rest` is a [Flask](https://flask.palletsprojects.com/) REST API that wraps the
+[FLAMAPY](https://flamapy.github.io/) framework for **feature model analysis**. It dynamically
+exposes FLAMAPY operations (dead features, false-optional features, configurations, satisfiability,
+diagnosis, …) as HTTP endpoints, with self-generated [Swagger](https://swagger.io/) documentation.
+
+Feature model analysis has a crucial role in software product line engineering, enabling us to
+understand, design, and validate the complex relationships among features in a software product
+line. These models can be complex and challenging to analyze due to their variability, making it
+difficult to identify conflicts, dead features, and potential optimizations. This REST API makes
+that analysis available to any tool or language that can speak HTTP.
+
+Please note: this is a living document and we will continue to update and improve it as we release
+new versions of the plugins and receive feedback from our users. If there's anything you don't
+understand or if you have any suggestions for improvement, don't hesitate to
+[open an issue](https://github.com/flamapy/flamapy-rest/issues). We're here to help!
+
+### Built With
+
+* [Docker](https://www.docker.com/)
+* [Flask](https://flask.palletsprojects.com/)
+* [FLAMAPY](https://github.com/flamapy)
+* [Flasgger](https://github.com/flasgger/flasgger)
+
+<p align="right">(<a href="#top">back to top</a>)</p>
+
+<!-- GETTING STARTED -->
+## Getting Started
+
+There are three supported ways to run the API. **Using the published Docker image is the easiest** —
+nothing to build, and it already bundles FLAMAPY and all of its analysis plugins.
+
+### Option 1 — Run the published Docker image (recommended)
+
+The CI publishes a multi-arch image (`linux/amd64` and `linux/arm64`) to Docker Hub at
+[`flamapy/flamapy-rest`](https://hub.docker.com/r/flamapy/flamapy-rest) on every version tag.
+
+```bash
+# Pull and run the latest release
+docker run --rm -p 8000:8000 flamapy/flamapy-rest
+```
+
+Then open:
+
+* API home: <http://localhost:8000/>
+* Swagger UI / API docs: <http://localhost:8000/docs/>
+
+To pin a specific version, use its tag (matching a release, e.g. `v2.6.0`):
+
+```bash
+docker run --rm -p 8000:8000 flamapy/flamapy-rest:v2.6.0
+```
+
+Run it detached and give the container a name so it's easy to stop later:
+
+```bash
+docker run -d --name flamapy-rest -p 8000:8000 flamapy/flamapy-rest
+docker logs -f flamapy-rest   # follow the logs
+docker stop flamapy-rest      # stop it
+docker rm flamapy-rest        # remove it
+```
+
+### Option 2 — Build the Docker image from source
+
+If you want to run your local changes, clone the repo and build the image yourself. A helper script
+is provided that builds, runs, and (on exit) cleans up the container and image:
+
+```bash
+# Linux / macOS
+./start-server.sh
+
+# Windows
+start-server.cmd
+```
+
+Or do it by hand:
+
+```bash
+docker build --tag flamapy-rest .
+docker run --rm -p 8000:8000 flamapy-rest
+```
+
+### Option 3 — Install from PyPI and run locally
+
+The API is also published on PyPI as [`flamapy-rest`](https://pypi.org/project/flamapy-rest/)
+(requires **Python 3.11+**). Because the WSGI entrypoint lives in `app.py`, clone the repo to get it:
+
+```bash
+git clone https://github.com/flamapy/flamapy-rest.git
+cd flamapy-rest
+pip install .
+
+# Production server
+gunicorn --bind 0.0.0.0:8000 app:app
+
+# …or the Flask development server
+python -m flask run --host=0.0.0.0
+```
+
+<p align="right">(<a href="#top">back to top</a>)</p>
+
+## Usage
+
+Every public operation of FLAMAPY's `FLAMAFeatureModel` facade is exposed as a `POST` endpoint under
+`/api/v1/operations/<operation_name>`. Each call uploads a feature model file (e.g. UVL) as
+multipart form data; some operations also accept an optional `feature` or `configuration` parameter.
+
+```bash
+# Example: count the number of valid configurations of a model
+curl -X POST http://localhost:8000/api/v1/operations/configurations_number \
+  -F "model=@resources/models/simple/valid_model.uvl"
+```
+
+The full, interactive list of endpoints — with parameters and "try it out" support — is available
+in the Swagger UI at <http://localhost:8000/docs/>.
+
+<p align="right">(<a href="#top">back to top</a>)</p>
+
+## Abuse controls & configuration
+
+The API ships with per-IP rate limiting, a per-operation time budget, upload size limits and a
+result cache, all configurable through environment variables (e.g. `docker run -e FLAMAPY_...`):
+
+| Env var | Default | Meaning |
+|---|---|---|
+| `FLAMAPY_MAX_CONTENT_LENGTH` | `16777216` | Max upload size in bytes; larger requests get **413** |
+| `FLAMAPY_RATELIMIT_ENABLED` | `true` | Turn rate limiting on/off |
+| `FLAMAPY_RATELIMIT_DEFAULT` | `60 per minute` | Per-IP limit for cheap operations |
+| `FLAMAPY_RATELIMIT_EXPENSIVE` | `10 per minute` | Per-IP limit for enumeration/solver-heavy operations (`configurations`, `configurations_number`, `sampling`, …); exceeding a limit returns **429** |
+| `FLAMAPY_RATELIMIT_STORAGE_URI` | `memory://` | Limiter storage; use `redis://host:6379` when running several gunicorn workers so they share counters |
+| `FLAMAPY_OPERATION_TIMEOUT` | `60` | Seconds an operation may run before it is killed and **504** is returned; `0` disables |
+| `FLAMAPY_CACHE_TTL` | `3600` | Seconds a result stays cached (same model + operation + arguments); `0` disables. Responses carry an `X-Cache: HIT|MISS` header |
+| `FLAMAPY_CACHE_MAXSIZE` | `128` | Max cached results per worker |
+| `FLAMAPY_TRUST_PROXY` | `false` | Set to `true` behind a reverse proxy so rate limits see the real client IP (`X-Forwarded-For`) |
+| `WEB_CONCURRENCY` | `2` | gunicorn worker count (Docker image) |
+| `GUNICORN_TIMEOUT` | `120` | gunicorn hard worker timeout; keep it above `FLAMAPY_OPERATION_TIMEOUT` |
+
+Every request is logged to stdout (client IP, path, status, duration, upload size, cache result),
+so `docker logs` is enough to spot heavy users.
+
+<p align="right">(<a href="#top">back to top</a>)</p>
+
+## API Documentation
+
+All documentation is registered with Swagger UI and OAS 3.0, served at
+[`/docs/`](http://localhost:8000/docs/). It is generated dynamically by
+[Flasgger](https://github.com/flasgger/flasgger) from the route docstrings and method signatures, so
+**don't forget to document your code in the route files** — new operations show up automatically.
+
+<p align="right">(<a href="#top">back to top</a>)</p>
+
+## Contributing
+
+Contributions are welcome. This repo enforces
+[Conventional Commits](https://www.conventionalcommits.org/) on pull request titles, and runs Ruff,
+mypy, and pytest in CI.
+
+```bash
+pip install .[dev]   # install dev tooling
+
+ruff check .         # lint
+mypy -p flamapy      # static type checking
+pytest               # tests
+```
+
+<p align="right">(<a href="#top">back to top</a>)</p>

flamapy_rest-2.6.0.dev6.dist-info/RECORD

@@ -0,0 +1,8 @@
+flamapy/interfaces/rest/config.py,sha256=8_4g0TZuSddXO4RwHcCxjQaYYXSHPE84tA2KkbdBXcM,1347
+flamapy/interfaces/rest/extensions.py,sha256=OhzYNNZgdjgWkgKvm3dV9BUhNY9w2vo_DT2hrJsYlXs,1522
+flamapy/interfaces/rest/operations_routes.py,sha256=8yvZQE6EzncriRPhV47DnO_vSlWeQWyOJGmu1bSwX8E,9977
+flamapy/interfaces/rest/runner.py,sha256=xleTrUCxj5Ga-vLBIiHLJGUBAy0aTrRz0Xh7cJcbbNQ,2321
+flamapy_rest-2.6.0.dev6.dist-info/METADATA,sha256=cAORK8xzhloTd6QDEzI8l6O-VNL8lRByG8KmRp_OFXs,9150
+flamapy_rest-2.6.0.dev6.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+flamapy_rest-2.6.0.dev6.dist-info/top_level.txt,sha256=2YBI9dg4GVk28AJuyNu6dldi5Riwt5SP0zpNe2lSU5M,8
+flamapy_rest-2.6.0.dev6.dist-info/RECORD,,

flamapy_rest-2.6.0.dev2.dist-info/METADATA

@@ -1,118 +0,0 @@
-Metadata-Version: 2.4
-Name: flamapy-rest
-Version: 2.6.0.dev2
-Summary: Flamapy feature model is a distribution of the flama framework containing all plugins required to analyze feature models. It also offers a richer API and a complete command line interface and documentation.
-Author-email: Flamapy <flamapy@us.es>
-License-Expression: GPL-3.0-or-later
-Project-URL: Homepage, https://github.com/flamapy/flamapy-rest
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-Requires-Dist: Flask
-Requires-Dist: gunicorn
-Requires-Dist: flamapy~=2.6.0.dev2
-Requires-Dist: flask-swagger-ui
-Requires-Dist: flask-restplus
-Requires-Dist: flask_cors
-Requires-Dist: flasgger
-Provides-Extra: dev
-Requires-Dist: pytest; extra == "dev"
-Requires-Dist: pytest-mock; extra == "dev"
-Requires-Dist: ruff; extra == "dev"
-Requires-Dist: mypy; extra == "dev"
-Requires-Dist: coverage; extra == "dev"
-
-<div align="center">
-
-  <a href="">[![Pytest Testing Suite](https://github.com/flamapy/flamapy-rest/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/flamapy/flamapy-rest/actions/workflows/tests.yml)</a>
-  <a href="">[![Commits Syntax Checker](https://github.com/flamapy/flamapy-rest/actions/workflows/commits.yml/badge.svg?branch=main)](https://github.com/flamapy/flamapy-rest/actions/workflows/commits.yml)</a>
-  <a href="">![PyPI](https://img.shields.io/pypi/v/flamapy-rest?label=pypi%20package)
-  <a href="">![PyPI - Downloads](https://img.shields.io/pypi/dm/flamapy-rest)
-</div>
-
-# 
-
-<div id="top"></div>
-<br />
-<div align="center">
-
-  <h3 align="center">FLAMAPY rest API</h3>
-
-  <p align="center">
-    A new and easy way to use FLAMA
-    <br />
-    <a href="https://github.com/flamapy/flamapy-fm-dist/issues">Report Bug</a>
-    ·
-    <a href="https://github.com/flamapy/flamapy-fm-dist/issues">Request Feature</a>
-  </p>
-</div>
-<!-- ABOUT THE PROJECT -->
-
-## About The Project
-
-FLAMAPY Feature model distribution provides an easier way of using FLAMA when analysing feature models. It packs the most used plugins for analyis of feature models adding a layer of convenience to use the framework or integrate it. 
-
-Feature Model Analysis has a crucial role in software product line engineering, enabling us to understand, design, and validate the complex relationships among features in a software product line. These feature models can often be complex and challenging to analyze due to their variability, making it difficult to identify conflicts, dead features, and potential optimizations. This is where this distribution comes in.
-
-Please note: This is a living document and we will continue to update and improve it as we release new versions of the plugins and receive feedback from our users. If there's anything you don't understand or if you have any suggestions for improvement, don't hesitate to contact us. We're here to help!
-
-Three main interfaces are provided:
-* A REST API: The REST API allows for easy integration with other tools and applications. It is also a more user friendly interface for those who are not familiar with the command line.
-
-Whant it to runint, simply run
-```bash
-pip install flamapy-rest
-gunicorn --bind 0.0.0.0:8000 app:app
-```
-
-Alternatively, you can use docker in this way:
-```bash
-chmod +x start-server.sh
-./start-server.sh
-```
-Or go to [the render deployed version]() it isn't fast, but its free. 
-
-<p align="right">(<a href="#top">back to top</a>)</p>
-
-### Built With
-
-* [Docker](https://www.docker.com/)
-* [Flask](https://flask.palletsprojects.com/en/2.2.x/)
-* [FLAMAPY](https://github.com/flamapy)
-* [Flasgger](https://github.com/flasgger/flasgger)
-
-<p align="right">(<a href="#top">back to top</a>)</p>
-
-# Using the distribution REST API
-The easies way is to execute the following command: docker run -p 8000:8000 flamapy/flamapy-fm-dist and open localhost:8000
-<!-- GETTING STARTED -->
-## Getting Started
-
-To get a local copy up and running follow these simple example steps.
-
-First, you will need to install [Docker](https://docs.docker.com/desktop/).
-
-### Instalation
-
-1. Clone the repository
-
-2. If you are running Windows, run
-  ```sh
-  $ cd flamapy-dm-dist
-  $ ./start-server.cmd
-  ```
-  
-3. If you are running Linux or MacOS, run
-  ```sh
-  $ cd flamapy-dm-dist
-  $ ./start-server.sh
-  ```
-  
-This script will build, install and deploy the API in http://localhost:8000, you can access all the endpoints through an application like [Postman](https://www.postman.com/)
-
-<p align="right">(<a href="#top">back to top</a>)</p>
-
-### API Documentation
-
-All the documentation is registered with Swagger UI and OAS 3.0. It is accesible through /api/v1/docs. This documentation is generated dinamically by relyin gon flasgger. DO not forget to document your code in the route files!
-
-<p align="right">(<a href="#top">back to top</a>)</p>

flamapy_rest-2.6.0.dev2.dist-info/RECORD

@@ -1,5 +0,0 @@
-flamapy/interfaces/rest/operations_routes.py,sha256=UXTYUuBcF5bOJpCizjJlnBYHDIcok3rFbzV3cWBepDw,7638
-flamapy_rest-2.6.0.dev2.dist-info/METADATA,sha256=OgTy_GMbKr6WPf6gJahTRwf6kNxgYZtAsE5XOaqB32c,4794
-flamapy_rest-2.6.0.dev2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-flamapy_rest-2.6.0.dev2.dist-info/top_level.txt,sha256=2YBI9dg4GVk28AJuyNu6dldi5Riwt5SP0zpNe2lSU5M,8
-flamapy_rest-2.6.0.dev2.dist-info/RECORD,,