PySMT 0.9.7.dev390__tar.gz → 0.9.7.dev408__tar.gz

{pysmt-0.9.7.dev390/PySMT.egg-info → pysmt-0.9.7.dev408}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PySMT
-Version: 0.9.7.dev390
+Version: 0.9.7.dev408
 Summary: A solver-agnostic library for SMT Formulae manipulation and solving
 Home-page: http://www.pysmt.org
 Author: PySMT Team

{pysmt-0.9.7.dev390 → pysmt-0.9.7.dev408/PySMT.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PySMT
-Version: 0.9.7.dev390
+Version: 0.9.7.dev408
 Summary: A solver-agnostic library for SMT Formulae manipulation and solving
 Home-page: http://www.pysmt.org
 Author: PySMT Team

{pysmt-0.9.7.dev390 → pysmt-0.9.7.dev408}/pysmt/__init__.py

@@ -19,7 +19,7 @@
 from typing import Tuple, Union
 
 
-VERSION: Union[Tuple[int, int, int], Tuple[int, int, int, str, int]] = (0, 9, 7, "dev", 390)
+VERSION: Union[Tuple[int, int, int], Tuple[int, int, int, str, int]] = (0, 9, 7, "dev", 408)
 
 # Try to provide human-readable version of latest commit for dev versions
 # E.g. v0.5.1-4-g49a49f2-wip

{pysmt-0.9.7.dev390 → pysmt-0.9.7.dev408}/pysmt/cmd/install.py

@@ -43,7 +43,7 @@ INSTALLERS = [
               {"pypicosat_minor_version" : "1708010052"}),
     Installer(CuddInstaller,    "2.0.3",
               {"git_version" : "ecb03d6d231273343178f566cc4d7258dcce52b4"}),
-    Installer(OptiMSatInstaller, "1.7.3", {})
+    Installer(OptiMSatInstaller, "1.7.5", {})
 ]
 
 

{pysmt-0.9.7.dev390 → pysmt-0.9.7.dev408}/pysmt/cmd/installers/optimsat.py

@@ -24,18 +24,26 @@ class OptiMSatInstaller(SolverInstaller):
 
     def __init__(self, install_dir, bindings_dir, solver_version,
                  mirror_link=None):
+
         # Getting the right archive name
-        os_name = self.os_name
-        arch = str(self.bits) + "-bit"
-        ext = "tar.gz"
-        if os_name == "windows":
-            ext = "zip"
-            arch += "-mingw"
-        elif os_name == "darwin":
-            os_name = "macos"
-
-        archive_name = "optimathsat-%s-%s-%s.%s" % (solver_version, os_name,
-                                                    arch, ext)
+        archive_name_template = "optimathsat-{version}-{os}-{arch}.{ext}"
+        format = {
+                "version": solver_version,
+                "os" : self.os_name,
+                "arch": self.architecture,
+                "ext": "tar.gz"
+        }
+        if self.os_name in ["windows", "darwin"]:
+            # Since version 1.7.5 the architecture is not included in the
+            # pkg name for the OSX and Win release as it is considered a "universal binary"
+            archive_name_template = "optimathsat-{version}-{os}.{ext}"
+        if self.os_name == "windows":
+            format["ext"] = "zip"
+            format["os"] = "win64" if self.architecture == "x86_64" else "win32"
+        elif self.os_name == "darwin":
+            format["os"] = "osx"
+
+        archive_name = archive_name_template.format(**format)
 
         native_link = "https://optimathsat.disi.unitn.it/releases/optimathsat-%s/{archive_name}" % solver_version
 

{pysmt-0.9.7.dev390 → pysmt-0.9.7.dev408}/pysmt/optimization/optimsat.py

@@ -144,9 +144,18 @@ class OptiMSATSolver(MathSAT5Solver, Optimizer):
         }
 
         while self.solve():
-            if all(self._check_unsat_unbound_infinitesimal(mo) for mo in msat_objs.values()):
-                model = self.get_model()
-                yield model, [model.get_value(goal.term()) for goal in goals]
+            all_ok = True
+            costs = []
+            model = None
+            for goal in goals:
+                result = self._get_goal_value(msat_objs[goal], goal)
+                if result is None:
+                    all_ok = False
+                    break
+                model, cost = result
+                costs.append(cost)
+            if all_ok and model is not None:
+                yield model, costs
             else:
                 break
         # set after the solve because the solve method has the clear_pending_pop decorator

{pysmt-0.9.7.dev390 → pysmt-0.9.7.dev408}/pysmt/smtlib/parser/parser.py

@@ -1312,15 +1312,39 @@ class SmtLibParser(object):
 
     def _cmd_minmax_maxmin_obj(self, current: str, tokens: Tokenizer) -> SmtLibCommand:
         """(minmax | maxmin <term>+ )"""
-        """TODO: [:id <string>] [:signed]"""
-        params = []
+        params: List[Tuple[str, Union[str, bool]]] = []
+        terms = []
+        signed = False
+        options = False
+
         while True:
-            try:
-                c = self.get_expression(tokens)
-                params.append(c)
-            except PysmtSyntaxError:
+            token = tokens.consume()
+            if token == ")":
                 break
-        return SmtLibCommand(current, [params,None])
+            if token.startswith(":"):
+                options = True
+                if token == ":id":
+                    identifier = self.parse_atom(tokens, "maxmin/minmax")
+                    params.append((token, identifier))
+                elif token == ":signed":
+                    signed = True
+                    params.append((token, signed))
+                else:
+                    raise PysmtSyntaxError(
+                        "Incorrect option in the '%s' command" % token,
+                        tokens.pos_info)
+            else:
+                if options:
+                    raise PysmtSyntaxError(
+                        "Unexpected token '%s' after options in the '%s' command" % (token, current),
+                        tokens.pos_info)
+                tokens.add_extra_token(token)
+                terms.append(self.get_expression(tokens))
+
+        if not any(option[0] == ":signed" for option in params):
+            params.append((":signed", False))
+
+        return SmtLibCommand(current, [terms, params])
 
     def _cmd_objective(self, current: str, tokens: Tokenizer) -> SmtLibCommand:
         """(maximize | minimize <term>"""

{pysmt-0.9.7.dev390 → pysmt-0.9.7.dev408}/pysmt/smtlib/script.py

@@ -122,9 +122,15 @@ class SmtLibCommand(namedtuple('SmtLibCommand', ['name', 'args'])):
 
         elif self.name in [smtcmd.MINMAX, smtcmd.MAXMIN]:
             outstream.write("(%s" % self.name)
-            for a in self.args:
+            for a in self.args[0]:
                 outstream.write(" ")
                 printer.printer(a)
+            for option_name, value in self.args[1] or []:
+                if option_name == ":signed":
+                    if value:
+                        outstream.write(" %s" % option_name)
+                else:
+                    outstream.write(" %s %s" % (option_name, value))
             outstream.write(")")
 
         elif self.name == smtcmd.CHECK_ALLSAT:

{pysmt-0.9.7.dev390 → pysmt-0.9.7.dev408}/pysmt/test/optimization_utils.py

@@ -242,9 +242,8 @@ def check_pareto(optimizer: Optimizer, goals: Sequence[Goal], goals_values: Sequ
     raised_class = _get_expected_raised_class(goals_values[0])
     assert raised_class is None or len(goals_values) == 1, "test: %s, goals_values: %s" % (test_id_str, str(goals_values))
     if raised_class is None:
-        iterator_retval = optimizer.pareto_optimize(goals, **kwargs)
-        assert iterator_retval is not None, test_id_str
-        retval = list(iterator_retval)
+        retval = optimizer.pareto_optimize(goals, **kwargs)
+        assert retval is not None, test_id_str
 
         sorted_costs = sorted((costs for _, costs in retval), key=str)
         sorted_goals_values = sorted(goals_values, key=str)
@@ -257,7 +256,7 @@ def check_pareto(optimizer: Optimizer, goals: Sequence[Goal], goals_values: Sequ
                 assert isinstance(goal_value, FNode)
                 _check_oracle_goal(goal, goal_value, cost, test_id_str, **kwargs)
 
-        return retval
+        return None
     elif not optimizer.can_diverge_for_unbounded_cases():
         with pytest.raises(raised_class):
             return list(optimizer.pareto_optimize(goals, **kwargs))

{pysmt-0.9.7.dev390 → pysmt-0.9.7.dev408}/pysmt/test/smtlib/test_omt_lib_solver.py

@@ -338,11 +338,8 @@ sat
         )
 
 
-test_to_skip = {
-        ("QF_LRA - smtlib2_boxed.smt2", OptimizationTypes.LEXICOGRAPHIC, "optimsat"), # error return wrong maximization of z (should be 24, returns 0); seems like a bug in optimsat; have to try optimsat alone; with integers instead of reals it works
-        ("QF_LIA - smtlib2_allsat.smt2", OptimizationTypes.PARETO, "optimsat"), # error that happens only if test_optimizing is done before this test
-        ("QF_LIA - smtlib2_load_objective_model.smt2", OptimizationTypes.PARETO, "optimsat"), # error that happens only if test_optimizing is done before this test
-}
+test_to_skip: dict = {}
+
 @pytest.mark.parametrize(
     "optimization_example, solver_name",
     generate_examples_with_solvers(omt_test_cases_from_smtlib_test_set()),

{pysmt-0.9.7.dev390 → pysmt-0.9.7.dev408}/pysmt/test/smtlib/test_parser_omt.py

@@ -63,6 +63,139 @@ class TestSmtLibParserOMT(TestCase):
             self.assertEqual(cmd.name, command)
             self.assertEqual(len(cmd.args), len_args)
 
+    def test_parse_minmax_maxmin_with_options(self):
+        parser = SmtLibParser()
+
+        script = parser.get_script(StringIO(
+            "(declare-fun x () Real)\n"
+            "(declare-fun y () Real)\n"
+            "(minmax x y :id g1 :signed)\n"
+        ))
+        cmd = script.commands[-1]
+        self.assertEqual(cmd.name, "minmax")
+        self.assertEqual(cmd.args[1], [(':id', 'g1'), (':signed', True)])
+
+        buf = StringIO()
+        script.serialize(buf)
+        self.assertIn("(minmax x y :id g1 :signed)", buf.getvalue())
+
+        script = parser.get_script(StringIO(
+            "(declare-fun x () Real)\n"
+            "(declare-fun y () Real)\n"
+            "(maxmin x y :id g2)\n"
+        ))
+        cmd = script.commands[-1]
+        self.assertEqual(cmd.name, "maxmin")
+        self.assertEqual(cmd.args[1], [(':id', 'g2'), (':signed', False)])
+
+    def test_parse_minmax_maxmin_signed_only(self):
+        parser = SmtLibParser()
+
+        script = parser.get_script(StringIO(
+            "(declare-fun x () Real)\n"
+            "(declare-fun y () Real)\n"
+            "(maxmin x y :signed)\n"
+        ))
+        cmd = script.commands[-1]
+        self.assertEqual(cmd.name, "maxmin")
+        self.assertEqual(cmd.args[1], [(':signed', True)])
+
+        buf = StringIO()
+        script.serialize(buf)
+        self.assertIn("(maxmin x y :signed)", buf.getvalue())
+
+    def test_parse_minmax_maxmin_invalid_option(self):
+        parser = SmtLibParser()
+        with self.assertRaises(PysmtSyntaxError):
+            parser.get_script(StringIO(
+                "(declare-fun x () Real)\n"
+                "(declare-fun y () Real)\n"
+                "(minmax x y :foo 1)\n"
+            ))
+
+    def test_parse_minmax_multiple_terms_with_options(self):
+        parser = SmtLibParser()
+
+        script = parser.get_script(StringIO(
+            "(declare-fun x () Real)\n"
+            "(declare-fun y () Real)\n"
+            "(declare-fun z () Real)\n"
+            "(minmax x y z :id g1 :signed)\n"
+        ))
+        cmd = script.commands[-1]
+        self.assertEqual(cmd.name, "minmax")
+        self.assertEqual([term.symbol_name() for term in cmd.args[0]], ['x', 'y', 'z'])
+        self.assertEqual(cmd.args[1], [(':id', 'g1'), (':signed', True)])
+
+        buf = StringIO()
+        script.serialize(buf)
+        self.assertIn("(minmax x y z :id g1 :signed)", buf.getvalue())
+
+    def test_parse_minmax_option_order(self):
+        parser = SmtLibParser()
+
+        script = parser.get_script(StringIO(
+            "(declare-fun x () Real)\n"
+            "(declare-fun y () Real)\n"
+            "(maxmin x y :signed :id g2)\n"
+        ))
+        cmd = script.commands[-1]
+        self.assertEqual(cmd.name, "maxmin")
+        self.assertEqual(cmd.args[1], [(':signed', True), (':id', 'g2')])
+
+        buf = StringIO()
+        script.serialize(buf)
+        self.assertIn("(maxmin x y :signed :id g2)", buf.getvalue())
+
+    def test_parse_minmax_reverse_option_order(self):
+        parser = SmtLibParser()
+
+        script = parser.get_script(StringIO(
+            "(declare-fun x () Real)\n"
+            "(declare-fun y () Real)\n"
+            "(minmax x y :signed :id g1)\n"
+        ))
+        cmd = script.commands[-1]
+        self.assertEqual(cmd.name, "minmax")
+        self.assertEqual(cmd.args[1], [(':signed', True), (':id', 'g1')])
+
+        buf = StringIO()
+        script.serialize(buf)
+        self.assertIn("(minmax x y :signed :id g1)", buf.getvalue())
+
+    def test_parse_minmax_maxmin_syntax_errors(self):
+        parser = SmtLibParser()
+        with self.assertRaises(PysmtSyntaxError):
+            parser.get_script(StringIO(
+                "(declare-fun x () Real)\n"
+                "(declare-fun y () Real)\n"
+                "(minmax x y :id)\n"
+            ))
+        with self.assertRaises(PysmtSyntaxError):
+            parser.get_script(StringIO(
+                "(declare-fun x () Real)\n"
+                "(declare-fun y () Real)\n"
+                "(maxmin x y :signed true)\n"
+            ))
+
+    def test_parse_minmax_maxmin_round_trip(self):
+        parser = SmtLibParser()
+        txt = """(declare-fun x () Real)
+(declare-fun y () Real)
+(minmax x y :id g1 :signed)
+(maxmin x y :signed :id g2)
+"""
+        script = parser.get_script(StringIO(txt))
+
+        buf = StringIO()
+        script.serialize(buf)
+        new_script = parser.get_script(StringIO(buf.getvalue()))
+
+        self.assertEqual(script.commands[-2].name, new_script.commands[-2].name)
+        self.assertEqual(script.commands[-2].args[1], new_script.commands[-2].args[1])
+        self.assertEqual(script.commands[-1].name, new_script.commands[-1].name)
+        self.assertEqual(script.commands[-1].args[1], new_script.commands[-1].args[1])
+
     def parse_from_file(self, file_id: int) -> SmtLibScript:
         fname = OMT_FILE_PATTERN % file_id
         reset_env()

{pysmt-0.9.7.dev390 → pysmt-0.9.7.dev408}/pysmt/test/test_optimizing.py

@@ -20,10 +20,7 @@ import pytest
 from pysmt.test.omt_examples import get_full_example_omt_formuale
 from pysmt.test.optimization_utils import generate_examples_with_solvers, solve_given_example, OptimizationTypes
 
-test_to_skip = {
-    ("QF_LIA 2 int 2 bools multiple objective", OptimizationTypes.PARETO, "optimsat"), # weird error, this test fails only if executed test_omt_lib_solver (skipping ("QF_LIA - smtlib2_load_objective_model.smt2", OptimizationTypes.PARETO, "optimsat") this skip becomes necessary, otherwise not). The cost returned is 0 when it should be 1
-    ("QF_LIA 2 variables multiple objective", OptimizationTypes.PARETO, "optimsat"), # weird error, this test fails only if executed after test_optimization, while it works on it's own
-}
+test_to_skip: dict = {}
 
 @pytest.mark.parametrize(
     "optimization_example, solver_name",