Add explicit ability for Driver objects to report available solvers

Solves #32

Author: Dekker1

CHANGELOG.rst

@@ -11,17 +11,23 @@ Unreleased_
 
 Added
 ^^^^^
+
 - Add (generated) ``__version__`` field to the package to abide by the PEP
   recommendations
 - Add support for using NumPy types to instantiate Models. (``np.array`` and
   any type that falls under ``np.generic``)
+- Add ``available_solvers`` method to the ``Driver`` objects to explicitly
+  report the available solvers according to the current environment
 
 Changed
 ^^^^^^^
+
 - **BREAKING:** Update minimal supported MiniZinc version to 2.5.0 to ensure
   full functionality.
 - Remove the (additional) hard time-out in from the CLI driver. MiniZinc should
   correctly enforce set time limit.
+- ``Solver.lookup`` now has an extra ``refresh`` argument to signal whether
+  the driver should refresh the found solver configurations.
 
 Fixed
 ^^^^^

src/minizinc/CLI/driver.py

@@ -2,12 +2,14 @@
 #  License, v. 2.0. If a copy of the MPL was not distributed with this
 #  file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
+import json
 import re
 import subprocess
 import sys
 import warnings
 from asyncio import create_subprocess_exec
 from asyncio.subprocess import PIPE, Process
+from dataclasses import fields
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Set, Type, Union
 
@@ -81,6 +83,7 @@ class CLIDriver(Driver):
     """
 
     _executable: Path
+    _solver_cache: Optional[Dict[str, Solver]] = None
 
     def __init__(self, executable: Path):
         self._executable = executable
@@ -222,3 +225,30 @@ def check_version(self):
                 f"version {found}. The minimal required version is "
                 f"{CLI_REQUIRED_VERSION}."
             )
+
+    def available_solvers(self, refresh=False):
+        if not refresh and self._solver_cache is not None:
+            return self._solver_cache
+
+        # Find all available solvers
+        output = self.run(["--solvers-json"])
+        solvers = json.loads(output.stdout)
+
+        # Construct Solver objects
+        self._solver_cache = {}
+        allowed_fields = set([f.name for f in fields(Solver)])
+        for s in solvers:
+            obj = Solver(
+                **{key: value for (key, value) in s.items() if key in allowed_fields}
+            )
+            if obj.version == "<unknown version>":
+                obj._identifier = obj.id
+            else:
+                obj._identifier = obj.id + "@" + obj.version
+
+            names = s.get("tags", [])
+            names.extend([s["id"], s["id"].split(".")[-1]])
+            for name in names:
+                self._solver_cache.setdefault(name, []).append(obj)
+
+        return self._solver_cache

src/minizinc/driver.py

@@ -62,6 +62,25 @@ def check_version(self) -> None:
         """
         pass
 
+    @abstractmethod
+    def available_solvers(self, refresh=False):
+        """Returns a list of available solvers
+
+        This method returns the list of solvers available to the Driver object
+        according to the current environment. Note that the list of solvers might
+        be cached for future usage. The refresh argument can be used to ignore
+        the current cache.
+
+        Args:
+            refresh (bool): When set to true, the Driver will rediscover the
+                available solvers from the current environment.
+
+        Returns:
+            Dict[str, List[Solver]]: A dictionary that maps solver tags to MiniZinc
+                solver configurations that can be used with the Driver object.
+        """
+        pass
+
 
 def find_driver(
     path: Optional[List[str]] = None, name: str = "minizinc"

src/minizinc/solver.py

@@ -6,9 +6,9 @@
 import json
 import os
 import tempfile
-from dataclasses import dataclass, field, fields
+from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any, Dict, Iterator, List, Optional, Set, Tuple
+from typing import Iterator, List, Optional, Tuple
 
 import minizinc
 
@@ -109,7 +109,7 @@ class Solver:
     _identifier: Optional[str] = None
 
     @classmethod
-    def lookup(cls, tag: str, driver=None):
+    def lookup(cls, tag: str, driver=None, refresh=False):
         """Lookup a solver configuration in the driver registry.
 
         Access the MiniZinc driver's known solver configuration and find the
@@ -121,6 +121,7 @@ def lookup(cls, tag: str, driver=None):
             tag (str): tag (or id) of a solver configuration to look up.
             driver (Driver): driver which registry will be searched for the
                 solver. If set to None, then ``default_driver`` will be used.
+            refresh (bool): Forces the driver to refresh the cache of available solvers.
 
         Returns:
             Solver: MiniZinc solver configuration compatible with the driver.
@@ -131,41 +132,17 @@ def lookup(cls, tag: str, driver=None):
         """
         if driver is None:
             driver = minizinc.default_driver
-        from .CLI.driver import CLIDriver
+        assert driver is not None
 
-        assert isinstance(driver, CLIDriver)
-        if driver is not None:
-            output = driver.run(["--solvers-json"])
-        else:
-            raise LookupError("Solver is not linked to a MiniZinc driver")
-        # Find all available solvers
-        solvers = json.loads(output.stdout)
+        tag_map = driver.available_solvers(refresh)
 
-        # Find the specified solver
-        lookup: Optional[Dict[str, Any]] = None
-        names: Set[str] = set()
-        for s in solvers:
-            s_names = [s["id"], s["id"].split(".")[-1]]
-            s_names.extend(s.get("tags", []))
-            names = names.union(set(s_names))
-            if tag in s_names:
-                lookup = s
-                break
-        if lookup is None:
+        if tag not in tag_map or len(tag_map[tag]) < 1:
             raise LookupError(
                 f"No solver id or tag '{tag}' found, available options: "
-                f"{sorted([x for x in names])}"
+                f"{sorted(tag_map.keys())}"
             )
 
-        allowed_fields = set([f.name for f in fields(cls)])
-        ret = cls(
-            **{key: value for (key, value) in lookup.items() if key in allowed_fields}
-        )
-        if ret.version == "<unknown version>":
-            ret._identifier = ret.id
-        else:
-            ret._identifier = ret.id + "@" + ret.version
-        return ret
+        return tag_map[tag][0]
 
     @classmethod
     def load(cls, path: Path):