PySMT 0.9.7.dev337__py2.py3-none-any.whl → 0.9.7.dev354__py2.py3-none-any.whl

pysmt/__init__.py

@@ -16,7 +16,7 @@
 #   limitations under the License.
 #
 
-VERSION = (0, 9, 7, "dev", 337)
+VERSION = (0, 9, 7, "dev", 354)
 
 # Try to provide human-readable version of latest commit for dev versions
 # E.g. v0.5.1-4-g49a49f2-wip

pysmt/cmd/install.py

@@ -32,8 +32,8 @@ from pysmt import __version__ as pysmt_version
 Installer = namedtuple("Installer",
                        ["InstallerClass", "version", "extra_params"])
 INSTALLERS = [
-    Installer(MSatInstaller,    "5.6.10", {}),
-    Installer(CVC5Installer,    "1.1.2", {}),
+    Installer(MSatInstaller,    "5.6.16", {}),
+    Installer(CVC5Installer,    "1.3.3", {}),
     Installer(CVC4Installer,    "1.7-prerelease",
               {"git_version" : "391ab9df6c3fd9a3771864900c1718534c1e4666"}),
     Installer(Z3Installer,      "4.15.0", {}),

pysmt/cmd/installers/base.py

@@ -231,6 +231,16 @@ class SolverInstaller(object):
                 stderr.close()
 
 
+    @staticmethod
+    def replace_in_file(file_path, old_str, new_str):
+        """Replaces all occurrences of old_str with new_str in the given file"""
+        with open(file_path, "r") as f:
+            content = f.read()
+        content = content.replace(old_str, new_str)
+        with open(file_path, "w") as f:
+            f.write(content)
+
+
     @staticmethod
     def clean_dir(path):
         """Empties a (possibly non-existent) directory"""

pysmt/cmd/installers/msat.py

@@ -34,14 +34,14 @@ class MSatInstaller(SolverInstaller):
                 "ext": "tar.gz"
         }
         if self.os_name == "windows":
+            archive_name_template = "mathsat-{version}-{os}.{ext}"
             format["ext"] = "zip"
-            format["arch"] = "msvc"
-            format["os"] = "win64" if self.architecture == "x86_64" else "win32"
+            format["os"] = "win64"
         elif self.os_name == "darwin":
             # Since version 5.6.7 the architecture is not included in the
             # pkg name for the OSX release as it is considered a "univeral binary"
             archive_name_template = "mathsat-{version}-{os}.{ext}"
-            format["os"] = "osx"
+            format["os"] = "macos"
 
         archive_name = archive_name_template.format(**format)
 
@@ -61,19 +61,25 @@ class MSatInstaller(SolverInstaller):
         if self.os_name == "windows":
             libdir = os.path.join(self.python_bindings_dir, "../lib")
             incdir = os.path.join(self.python_bindings_dir, "../include")
-            gmp_h_url = "https://github.com/mikand/tamer-windows-deps/raw/master/gmp/include/gmp.h"
-            mpir_dll_url = "https://github.com/Legrandin/mpir-windows-builds/blob/master/mpir-2.6.0_VS2015_%s/mpir.dll?raw=true" % self.bits
-            mpir_lib_url = "https://github.com/Legrandin/mpir-windows-builds/blob/master/mpir-2.6.0_VS2015_%s/mpir.lib?raw=true" % self.bits
-            setup_py_win_url = "https://github.com/pysmt/solvers_patches/raw/master/mathsat/setup-win.py"
-
-            SolverInstaller.do_download(gmp_h_url, os.path.join(incdir, "gmp.h"))
-            SolverInstaller.do_download(mpir_dll_url, os.path.join(libdir, "mpir.dll"))
-            SolverInstaller.do_download(mpir_lib_url, os.path.join(libdir, "mpir.lib"))
 
-            # Overwrite setup.py with the patched version
-            setup_py = os.path.join(self.python_bindings_dir, "setup.py")
-            SolverInstaller.mv(setup_py, setup_py + ".original")
-            SolverInstaller.do_download(setup_py_win_url, setup_py)
+            gmp_win_url = "https://github.com/apotocki/gmp-win/releases/download/6.3.0/gmp-6.3.0.zip"
+            gmp_archive = os.path.join(self.base_dir, "gmp-6.3.0.zip")
+            gmp_dir = os.path.join(self.base_dir, "gmp-6.3.0")
+            SolverInstaller.clean_dir(gmp_dir)
+            SolverInstaller.do_download(url=gmp_win_url, file_name=gmp_archive)
+            SolverInstaller.unzip(gmp_archive, gmp_dir)
+
+            gmp_include_dir = os.path.join(self.base_dir, "gmp-6.3.0", "include")
+            gmp_lib_dir = os.path.join(self.base_dir, "gmp-6.3.0", "lib")
+            # gmp_dll_dir = os.path.join(self.base_dir, "gmp-6.3.0", "bin")
+            SolverInstaller.mv(os.path.join(gmp_include_dir, "gmp.h"), incdir)
+            SolverInstaller.mv(source=os.path.join(gmp_lib_dir, "gmpdll.lib"),
+                               dest=os.path.join(libdir, "gmp.lib"))
+
+            # The MathSAT setup.py expects to link against "mpir" on Windows,
+            # but we link against "gmp", so we need to patch the setup.py
+            setup_py_path = os.path.join(self.python_bindings_dir, "setup.py")
+            SolverInstaller.replace_in_file(setup_py_path, "mpir", "gmp")
 
         # Run setup.py to compile the bindings
         if self.os_name in {"windows", "darwin"}:
@@ -89,11 +95,11 @@ class MSatInstaller(SolverInstaller):
         pdir = self.python_bindings_dir
         bdir = os.path.join(pdir, "build")
         sodir = glob.glob(bdir + "/lib.*")[0]
-        libdir = os.path.join(self.python_bindings_dir, "../lib")
+        libdir = os.path.join(self.python_bindings_dir, "../bin")
 
         # First, we need the SWIG-generated wrapper
         for f in os.listdir(sodir):
-            if f.endswith(".so") or f.endswith(".pyd"):
+            if "_mathsat" in f:
                 SolverInstaller.mv(os.path.join(sodir, f), self.bindings_dir)
         SolverInstaller.mv(os.path.join(pdir, "mathsat.py"), self.bindings_dir)
 
@@ -103,7 +109,7 @@ class MSatInstaller(SolverInstaller):
             if f.endswith(".so") or f.endswith(".dll") or f.endswith(".dylib"):
                 SolverInstaller.mv(os.path.join(libdir, f), self.bindings_dir)
 
-        # Fix issue in MathSAT 5.6.10 linking to incorrect directory on OSX
+        # Fix issue in MathSAT 5.6.10 linking to incorrect directory on MacOS
         if self.os_name == "darwin":
             soname = glob.glob(self.bindings_dir + "/_mathsat*.so")[0]
             old_path = "/Users/alb/src/release/build/libmathsat.dylib"

pysmt/cmd/installers/optimsat.py

@@ -37,7 +37,7 @@ class OptiMSatInstaller(SolverInstaller):
         archive_name = "optimathsat-%s-%s-%s.%s" % (solver_version, os_name,
                                                     arch, ext)
 
-        native_link = "http://optimathsat.disi.unitn.it/releases/optimathsat-%s/{archive_name}" % solver_version
+        native_link = "https://optimathsat.disi.unitn.it/releases/optimathsat-%s/{archive_name}" % solver_version
 
         SolverInstaller.__init__(self, install_dir=install_dir,
                                  bindings_dir=bindings_dir,

pysmt/cmd/installers/pico.py

@@ -11,9 +11,10 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-import sys, os
+import os
 import json
 import codecs
+import glob
 
 import urllib.request
 
@@ -59,10 +60,8 @@ class PicoSATInstaller(SolverInstaller):
         SolverInstaller.run_python("setup.py build", directory=self.extract_path)
 
     def move(self):
-        libdir = "lib.%s-%s-%s" % (self.os_name, self.architecture,
-                                   self.python_version)
         bdir = os.path.join(self.extract_path, "build")
-        sodir = os.path.join(bdir, libdir)
+        sodir = glob.glob(bdir + "/lib.*")[0]
 
         for f in os.listdir(sodir):
             if f.endswith(".so"):

pysmt/solvers/cvcfive.py

@@ -15,8 +15,6 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 #
-from __future__ import absolute_import
-
 from pysmt.exceptions import SolverAPINotFound
 
 try:
@@ -27,18 +25,18 @@ except ImportError:
 from cvc5 import Kind
 
 import pysmt.typing as types
-from pysmt.logics import PYSMT_LOGICS, ARRAYS_CONST_LOGICS
+from pysmt.logics import PYSMT_LOGICS, AUFLIRA, AUFLIA, AUFNIRA, ALIA
 
 from pysmt.solvers.solver import Solver, Converter, SolverOptions
 from pysmt.exceptions import (SolverReturnedUnknownResultError,
                               InternalSolverError,
-                              NonLinearError, PysmtValueError,
+                              PysmtValueError,
                               PysmtTypeError)
 from pysmt.walkers import DagWalker
 from pysmt.solvers.smtlib import SmtLibBasicSolver, SmtLibIgnoreMixin
 from pysmt.solvers.eager import EagerModel
 from pysmt.decorators import catch_conversion_error
-from pysmt.constants import Fraction, is_pysmt_integer, to_python_integer
+from pysmt.constants import Fraction, is_pysmt_integer
 
 
 class CVC5Options(SolverOptions):
@@ -51,51 +49,57 @@ class CVC5Options(SolverOptions):
             raise PysmtValueError("'unsat_cores_mode' option not supported.")
 
     @staticmethod
-    def _set_option(cvc5, name, value):
+    def _set_option(cvc5_solver, name, value):
         try:
-            cvc5.setOption(name, value)
+            cvc5_solver.setOption(name, value)
         except:
             raise PysmtValueError("Error setting the option '%s=%s'" % (name,value))
 
     def __call__(self, solver):
         if solver.logic_name == "QF_SLIA":
-            self._set_option(solver.cvc5,
+            self._set_option(solver.cvc5_solver,
                              "strings-exp", "true")
 
-        self._set_option(solver.cvc5,
+        self._set_option(solver.cvc5_solver,
                          "produce-models", str(self.generate_models).lower())
-        self._set_option(solver.cvc5,
+        self._set_option(solver.cvc5_solver,
                          "incremental", str(self.incremental).lower())
         if self.random_seed is not None:
-            self._set_option(solver.cvc5,
+            self._set_option(solver.cvc5_solver,
                              "seed", str(self.random_seed))
 
-        # self._set_option(solver.cvc5, "miplib-trick", "true")
-        # self._set_option(solver.cvc5, "miplib-trick-subs", "4")
-        # self._set_option(solver.cvc5, "use-approx", "true")
-        # self._set_option(solver.cvc5, "lemmas-on-replay-failure", "true")
-        # self._set_option(solver.cvc5, "replay-early-close-depth", "4")
-        # self._set_option(solver.cvc5, "replay-lemma-reject-cut", "128")
-        # self._set_option(solver.cvc5, "replay-reject-cut", "512")
-        # self._set_option(solver.cvc5, "unconstrained-simp", "true")
-        # self._set_option(solver.cvc5, "use-soi", "true")
-        # self._set_option(solver.cvc5, "pb-rewrites", "true")
-        self._set_option(solver.cvc5, "ite-simp", "true")
-        self._set_option(solver.cvc5, "simp-ite-compress", "true")
+        # self._set_option(solver.cvc5_solver, "miplib-trick", "true")
+        # self._set_option(solver.cvc5_solver, "miplib-trick-subs", "4")
+        # self._set_option(solver.cvc5_solver, "use-approx", "true")
+        # self._set_option(solver.cvc5_solver, "lemmas-on-replay-failure", "true")
+        # self._set_option(solver.cvc5_solver, "replay-early-close-depth", "4")
+        # self._set_option(solver.cvc5_solver, "replay-lemma-reject-cut", "128")
+        # self._set_option(solver.cvc5_solver, "replay-reject-cut", "512")
+        # self._set_option(solver.cvc5_solver, "unconstrained-simp", "true")
+        # self._set_option(solver.cvc5_solver, "use-soi", "true")
+        # self._set_option(solver.cvc5_solver, "pb-rewrites", "true")
+        # self._set_option(solver.cvc5_solver, "ite-simp", "true")
+        # self._set_option(solver.cvc5_solver, "simp-ite-compress", "true")
 
-        #self._set_option(solver.cvc5, "nl-ext-tplanes", "true")
+        #self._set_option(solver.cvc5_solver, "nl-ext-tplanes", "true")
 
 
         for k,v in self.solver_options.items():
-            self._set_option(solver.cvc5, str(k), str(v))
+            self._set_option(solver.cvc5_solver, str(k), str(v))
 
 # EOC CVC5Options
 
 
 class CVC5Solver(Solver, SmtLibBasicSolver, SmtLibIgnoreMixin):
 
-    LOGICS = PYSMT_LOGICS -\
-             ARRAYS_CONST_LOGICS
+    # Exclude const-array logics that mix BV with integer/real arithmetic:
+    # cvc5 rejects arrays indexed by array types (e.g. QF_AUFBVLIRA*).
+    LOGICS = (PYSMT_LOGICS | {AUFLIRA, AUFLIA, AUFNIRA, ALIA}) - \
+             frozenset(l for l in PYSMT_LOGICS
+                       if l.theory.arrays_const
+                       and l.theory.bit_vectors
+                       and (l.theory.integer_arithmetic
+                            or l.theory.real_arithmetic))
 
     OptionsClass = CVC5Options
 
@@ -104,9 +108,12 @@ class CVC5Solver(Solver, SmtLibBasicSolver, SmtLibIgnoreMixin):
                         environment=environment,
                         logic=logic,
                         **options)
-        self.cvc5 = cvc5.Solver()
+        self.cvc5_solver = cvc5.Solver()
         self.declarations = None
         self.logic_name = str(logic)
+        if self.logic_name.endswith("*"):
+            # Const-array extension (pySMT-internal suffix)
+            self.logic_name = self.logic_name[:-1]
         if "t" in self.logic_name:
             # Custom Type extension
             self.logic_name = self.logic_name.replace("t","")
@@ -114,14 +121,23 @@ class CVC5Solver(Solver, SmtLibBasicSolver, SmtLibIgnoreMixin):
             self.logic_name = "QF_LRA"
         elif self.logic_name == "BOOL":
             self.logic_name = "LRA"
-        self.cvc5.setLogic(self.logic_name)
+        self.cvc5_solver.setLogic(self.logic_name)
+
+        # Enable constant-array support (STORE_ALL / mkConstArray).
+        # Without this, cvc5 rejects assertions containing constant
+        # arrays with "Cannot handle assertion with term of kind
+        # STORE_ALL in this configuration."
+        try:
+            self.cvc5_solver.setOption("arrays-exp", "true")
+        except Exception:
+            pass  # older cvc5 versions may not have this option
 
         self.options(self)
 
-        self.converter = CVC5Converter(environment, cvc5=self.cvc5)
+        self.converter = CVC5Converter(environment, parent_solver=self)
 
     def reset_assertions(self):
-        self.cvc5.resetAssertions()
+        self.cvc5_solver.resetAssertions()
 
     def declare_variable(self, var):
         raise NotImplementedError
@@ -129,7 +145,7 @@ class CVC5Solver(Solver, SmtLibBasicSolver, SmtLibIgnoreMixin):
     def add_assertion(self, formula, named=None):
         self._assert_is_boolean(formula)
         term = self.converter.convert(formula)
-        self.cvc5.assertFormula(term)
+        self.cvc5_solver.assertFormula(term)
 
     def get_model(self):
         assignment = {}
@@ -143,10 +159,10 @@ class CVC5Solver(Solver, SmtLibBasicSolver, SmtLibIgnoreMixin):
     def solve(self, assumptions=None):
         if assumptions is not None:
             cvc5_assumptions = [self.converter.convert(a) for a in assumptions]
-            res = self.cvc5.checkSatAssuming(*cvc5_assumptions)
+            res = self.cvc5_solver.checkSatAssuming(*cvc5_assumptions)
         else:
             try:
-                res = self.cvc5.checkSat()
+                res = self.cvc5_solver.checkSat()
             except Exception as ex:
                 raise InternalSolverError(str(ex))
 
@@ -164,12 +180,12 @@ class CVC5Solver(Solver, SmtLibBasicSolver, SmtLibIgnoreMixin):
             raise NotImplementedError("The solver is not incremental")
 
         for _ in range(levels):
-            self.cvc5.push()
+            self.cvc5_solver.push()
         return
 
     def pop(self, levels=1):
         for _ in range(levels):
-            self.cvc5.pop()
+            self.cvc5_solver.pop()
         return
 
     def print_model(self, name_filter=None):
@@ -185,7 +201,7 @@ class CVC5Solver(Solver, SmtLibBasicSolver, SmtLibIgnoreMixin):
     def get_value(self, item):
         self._assert_no_function_type(item)
         term = self.converter.convert(item)
-        cvc5_res = self.cvc5.getValue(term)
+        cvc5_res = self.cvc5_solver.getValue(term)
         res = self.converter.back(cvc5_res)
         if self.environment.stc.get_type(item).is_real_type() and \
            self.environment.stc.get_type(res).is_int_type():
@@ -193,7 +209,8 @@ class CVC5Solver(Solver, SmtLibBasicSolver, SmtLibIgnoreMixin):
         return res
 
     def _exit(self):
-        del self.cvc5
+        del self.cvc5_solver
+
 
     def set_option(self, name, value):
         """Sets an option.
@@ -202,16 +219,16 @@ class CVC5Solver(Solver, SmtLibBasicSolver, SmtLibIgnoreMixin):
         :type name: String
         :type value: String
         """
-        self.cvc5.setOption(name, value)
+        self.cvc5_solver.setOption(name, value)
 
 
 
 class CVC5Converter(Converter, DagWalker):
 
-    def __init__(self, environment, cvc5):
+    def __init__(self, environment, parent_solver):
         DagWalker.__init__(self, environment)
 
-        self.cvc5 = cvc5
+        self.parent_solver = parent_solver
 
         self.declared_vars = {}
         self.backconversion = {}
@@ -219,13 +236,21 @@ class CVC5Converter(Converter, DagWalker):
         self._get_type = environment.stc.get_type
         return
 
+    @property
+    def cvc5_solver(self):
+        '''Returns the cvc5 solver instance from the parent solver.
+        This is needed because apparently cvc5.Solver cannot be aliased
+        (probably due to the wrapper) and therefore we cannot store it directly
+        in the converter.'''
+        return self.parent_solver.cvc5_solver
+
     def declare_variable(self, var):
         if not var.is_symbol():
             raise PysmtTypeError("Trying to declare as a variable something "
                                  "that is not a symbol: %s" % var)
         if var.symbol_name() not in self.declared_vars:
             cvc5_type = self._type_to_cvc5(var.symbol_type())
-            decl = self.cvc5.mkConst(cvc5_type, var.symbol_name())
+            decl = self.cvc5_solver.mkConst(cvc5_type, var.symbol_name())
             self.declared_vars[var] = decl
 
     def back(self, expr):
@@ -250,6 +275,11 @@ class CVC5Converter(Converter, DagWalker):
             array_type = self._cvc5_type_to_type(expr.getSort())
             base_value = self.back(const_)
             res = self.mgr.Array(array_type.index_type, base_value)
+        elif expr.getKind() == Kind.STORE:
+            base = self.back(expr[0])
+            index = self.back(expr[1])
+            value = self.back(expr[2])
+            res = self.mgr.Store(base, index, value)
         else:
             raise PysmtTypeError("Unsupported expression:", str(expr))
 
@@ -260,13 +290,13 @@ class CVC5Converter(Converter, DagWalker):
         return self.walk(formula)
 
     def walk_and(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.AND, *args)
+        return self.cvc5_solver.mkTerm(Kind.AND, *args)
 
     def walk_or(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.OR, *args)
+        return self.cvc5_solver.mkTerm(Kind.OR, *args)
 
     def walk_not(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.NOT, *args)
+        return self.cvc5_solver.mkTerm(Kind.NOT, *args)
 
     def walk_symbol(self, formula, args, **kwargs):
         #pylint: disable=unused-argument
@@ -275,238 +305,249 @@ class CVC5Converter(Converter, DagWalker):
         return self.declared_vars[formula]
 
     def walk_iff(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.EQUAL, args[0], args[1])
+        return self.cvc5_solver.mkTerm(Kind.EQUAL, args[0], args[1])
 
     def walk_implies(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.IMPLIES, args[0], args[1])
+        return self.cvc5_solver.mkTerm(Kind.IMPLIES, args[0], args[1])
 
     def walk_le(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.LEQ, args[0], args[1])
+        return self.cvc5_solver.mkTerm(Kind.LEQ, args[0], args[1])
 
     def walk_lt(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.LT, args[0], args[1])
+        return self.cvc5_solver.mkTerm(Kind.LT, args[0], args[1])
 
     def walk_ite(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.ITE, args[0], args[1], args[2])
+        return self.cvc5_solver.mkTerm(Kind.ITE, args[0], args[1], args[2])
 
     def walk_real_constant(self, formula, **kwargs):
         frac = formula.constant_value()
         n,d = frac.numerator, frac.denominator
         rep = str(n) + "/" + str(d)
-        return self.cvc5.mkReal(rep)
+        return self.cvc5_solver.mkReal(rep)
 
     def walk_int_constant(self, formula, **kwargs):
         assert is_pysmt_integer(formula.constant_value())
         rep = str(formula.constant_value())
-        return self.cvc5.mkInteger(rep)
+        return self.cvc5_solver.mkInteger(rep)
 
     def walk_bool_constant(self, formula, **kwargs):
-        return self.cvc5.mkBoolean(formula.constant_value())
+        return self.cvc5_solver.mkBoolean(formula.constant_value())
 
     def walk_exists(self, formula, args, **kwargs):
         (bound_formula, var_list) = \
                  self._rename_bound_variables(args[0], formula.quantifier_vars())
-        bound_vars_list = self.cvc5.mkTerm(Kind.VARIABLE_LIST, *var_list)
-        return self.cvc5.mkTerm(Kind.EXISTS,
+        bound_vars_list = self.cvc5_solver.mkTerm(Kind.VARIABLE_LIST, *var_list)
+        return self.cvc5_solver.mkTerm(Kind.EXISTS,
                            bound_vars_list,
                            bound_formula)
 
     def walk_forall(self, formula, args, **kwargs):
         (bound_formula, var_list) = \
                  self._rename_bound_variables(args[0], formula.quantifier_vars())
-        bound_vars_list = self.cvc5.mkTerm(Kind.VARIABLE_LIST, *var_list)
-        return self.cvc5.mkTerm(Kind.FORALL,
+        bound_vars_list = self.cvc5_solver.mkTerm(Kind.VARIABLE_LIST, *var_list)
+        return self.cvc5_solver.mkTerm(Kind.FORALL,
                            bound_vars_list,
                            bound_formula)
 
     def walk_plus(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.ADD, *args)
+        return self.cvc5_solver.mkTerm(Kind.ADD, *args)
 
     def walk_array_store(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.STORE, args[0], args[1], args[2])
+        return self.cvc5_solver.mkTerm(Kind.STORE, args[0], args[1], args[2])
 
     def walk_array_select(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.SELECT, args[0], args[1])
+        return self.cvc5_solver.mkTerm(Kind.SELECT, args[0], args[1])
+
+    def walk_array_value(self, formula, args, **kwargs):
+        arr_sort = self._type_to_cvc5(formula.get_type())
+        # args[0] is the converted default value
+        const_arr = self.cvc5_solver.mkConstArray(arr_sort, args[0])
+        # Remaining args are (index, value) pairs for point overrides
+        result = const_arr
+        for i in range(1, len(args), 2):
+            result = self.cvc5_solver.mkTerm(Kind.STORE, result, args[i], args[i + 1])
+        return result
 
     def walk_minus(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.SUB, args[0], args[1])
+        return self.cvc5_solver.mkTerm(Kind.SUB, args[0], args[1])
 
     def walk_equals(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.EQUAL, args[0], args[1])
+        return self.cvc5_solver.mkTerm(Kind.EQUAL, args[0], args[1])
 
     def walk_times(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.MULT, *args)
+        return self.cvc5_solver.mkTerm(Kind.MULT, *args)
 
     def walk_div(self, formula, args, **kwargs):
         if self.env.stc.get_type(formula).is_int_type():
-            return self.cvc5.mkTerm(Kind.INTS_DIVISION, *args)
+            return self.cvc5_solver.mkTerm(Kind.INTS_DIVISION, *args)
         else:
-            return self.cvc5.mkTerm(Kind.DIVISION, *args)
+            return self.cvc5_solver.mkTerm(Kind.DIVISION, *args)
 
     def walk_pow(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.POW, args[0], self.cvc5.mkTerm(Kind.TO_REAL, args[1]))
+        return self.cvc5_solver.mkTerm(Kind.TO_REAL,
+                                       self.cvc5_solver.mkTerm(Kind.POW, args[0], args[1]))
 
     def walk_toreal(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.TO_REAL, args[0])
+        return self.cvc5_solver.mkTerm(Kind.TO_REAL, args[0])
 
     def walk_function(self, formula, args, **kwargs):
         name = formula.function_name()
         if name not in self.declared_vars:
             self.declare_variable(name)
         decl = self.declared_vars[name]
-        return self.cvc5.mkTerm(Kind.APPLY_UF, decl, *args)
+        return self.cvc5_solver.mkTerm(Kind.APPLY_UF, decl, *args)
 
     def walk_bv_constant(self, formula, **kwargs):
         v = formula.constant_value()
         width = formula.bv_width()
-        return self.cvc5.mkBitVector(width, str(v), 10)
+        return self.cvc5_solver.mkBitVector(width, str(v), 10)
 
     def walk_bv_ult(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.BITVECTOR_ULT, args[0], args[1])
+        return self.cvc5_solver.mkTerm(Kind.BITVECTOR_ULT, args[0], args[1])
 
     def walk_bv_ule(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.BITVECTOR_ULE, args[0], args[1])
+        return self.cvc5_solver.mkTerm(Kind.BITVECTOR_ULE, args[0], args[1])
 
     def walk_bv_concat(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.BITVECTOR_CONCAT, args[0], args[1])
+        return self.cvc5_solver.mkTerm(Kind.BITVECTOR_CONCAT, args[0], args[1])
 
     def walk_bv_extract(self, formula, args, **kwargs):
-        ext = self.cvc5.mkOp(Kind.BITVECTOR_EXTRACT,
+        ext = self.cvc5_solver.mkOp(Kind.BITVECTOR_EXTRACT,
                              formula.bv_extract_end(),
                              formula.bv_extract_start())
-        return self.cvc5.mkTerm(ext, args[0])
+        return self.cvc5_solver.mkTerm(ext, args[0])
 
     def walk_bv_or(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.BITVECTOR_OR, args[0], args[1])
+        return self.cvc5_solver.mkTerm(Kind.BITVECTOR_OR, args[0], args[1])
 
     def walk_bv_not(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.BITVECTOR_NOT, args[0])
+        return self.cvc5_solver.mkTerm(Kind.BITVECTOR_NOT, args[0])
 
     def walk_bv_and(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.BITVECTOR_AND, args[0], args[1])
+        return self.cvc5_solver.mkTerm(Kind.BITVECTOR_AND, args[0], args[1])
 
     def walk_bv_xor(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.BITVECTOR_XOR, args[0], args[1])
+        return self.cvc5_solver.mkTerm(Kind.BITVECTOR_XOR, args[0], args[1])
 
     def walk_bv_add(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.BITVECTOR_ADD, *args)
+        return self.cvc5_solver.mkTerm(Kind.BITVECTOR_ADD, *args)
 
     def walk_bv_sub(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.BITVECTOR_SUB, args[0], args[1])
+        return self.cvc5_solver.mkTerm(Kind.BITVECTOR_SUB, args[0], args[1])
 
     def walk_bv_neg(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.BITVECTOR_NEG, args[0])
+        return self.cvc5_solver.mkTerm(Kind.BITVECTOR_NEG, args[0])
 
     def walk_bv_mul(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.BITVECTOR_MULT, args[0], args[1])
+        return self.cvc5_solver.mkTerm(Kind.BITVECTOR_MULT, args[0], args[1])
 
     def walk_bv_tonatural(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.BITVECTOR_TO_NAT, args[0])
+        return self.cvc5_solver.mkTerm(Kind.BITVECTOR_TO_NAT, args[0])
 
     def walk_bv_udiv(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.BITVECTOR_UDIV, *args)
+        return self.cvc5_solver.mkTerm(Kind.BITVECTOR_UDIV, *args)
 
     def walk_bv_urem(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.BITVECTOR_UREM, *args)
+        return self.cvc5_solver.mkTerm(Kind.BITVECTOR_UREM, *args)
 
     def walk_bv_lshl(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.BITVECTOR_SHL, args[0], args[1])
+        return self.cvc5_solver.mkTerm(Kind.BITVECTOR_SHL, args[0], args[1])
 
     def walk_bv_lshr(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.BITVECTOR_LSHR, args[0], args[1])
+        return self.cvc5_solver.mkTerm(Kind.BITVECTOR_LSHR, args[0], args[1])
 
     def walk_bv_rol(self, formula, args, **kwargs):
-        ext = self.cvc5.mkOp(Kind.BITVECTOR_ROTATE_LEFT, formula.bv_rotation_step())
-        return self.cvc5.mkTerm(ext, args[0])
+        ext = self.cvc5_solver.mkOp(Kind.BITVECTOR_ROTATE_LEFT, formula.bv_rotation_step())
+        return self.cvc5_solver.mkTerm(ext, args[0])
 
     def walk_bv_ror(self, formula, args, **kwargs):
-        ext = self.cvc5.mkOp(Kind.BITVECTOR_ROTATE_RIGHT, formula.bv_rotation_step())
-        return self.cvc5.mkTerm(ext, args[0])
+        ext = self.cvc5_solver.mkOp(Kind.BITVECTOR_ROTATE_RIGHT, formula.bv_rotation_step())
+        return self.cvc5_solver.mkTerm(ext, args[0])
 
     def walk_bv_zext(self, formula, args, **kwargs):
-        ext = self.cvc5.mkOp(Kind.BITVECTOR_ZERO_EXTEND, formula.bv_extend_step())
-        return self.cvc5.mkTerm(ext, args[0])
+        ext = self.cvc5_solver.mkOp(Kind.BITVECTOR_ZERO_EXTEND, formula.bv_extend_step())
+        return self.cvc5_solver.mkTerm(ext, args[0])
 
     def walk_bv_sext (self, formula, args, **kwargs):
-        ext = self.cvc5.mkOp(Kind.BITVECTOR_SIGN_EXTEND, formula.bv_extend_step())
-        return self.cvc5.mkTerm(ext, args[0])
+        ext = self.cvc5_solver.mkOp(Kind.BITVECTOR_SIGN_EXTEND, formula.bv_extend_step())
+        return self.cvc5_solver.mkTerm(ext, args[0])
 
     def walk_bv_slt(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.BITVECTOR_SLT, args[0], args[1])
+        return self.cvc5_solver.mkTerm(Kind.BITVECTOR_SLT, args[0], args[1])
 
     def walk_bv_sle(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.BITVECTOR_SLE, args[0], args[1])
+        return self.cvc5_solver.mkTerm(Kind.BITVECTOR_SLE, args[0], args[1])
 
     def walk_bv_comp(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.BITVECTOR_COMP, args[0], args[1])
+        return self.cvc5_solver.mkTerm(Kind.BITVECTOR_COMP, args[0], args[1])
 
     def walk_bv_sdiv(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.BITVECTOR_SDIV, *args)
+        return self.cvc5_solver.mkTerm(Kind.BITVECTOR_SDIV, *args)
 
     def walk_bv_srem(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.BITVECTOR_SREM, *args)
+        return self.cvc5_solver.mkTerm(Kind.BITVECTOR_SREM, *args)
 
     def walk_bv_ashr(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.BITVECTOR_ASHR, args[0], args[1])
+        return self.cvc5_solver.mkTerm(Kind.BITVECTOR_ASHR, args[0], args[1])
 
     def walk_str_constant(self, formula, args, **kwargs):
-        return self.cvc5.mkString(formula.constant_value())
+        return self.cvc5_solver.mkString(formula.constant_value())
 
     def walk_str_length (self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.STRING_LENGTH , args[0])
+        return self.cvc5_solver.mkTerm(Kind.STRING_LENGTH , args[0])
 
     def walk_str_concat(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.STRING_CONCAT, *args)
+        return self.cvc5_solver.mkTerm(Kind.STRING_CONCAT, *args)
 
     def walk_str_contains(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.STRING_CONTAINS, args[0], args[1])
+        return self.cvc5_solver.mkTerm(Kind.STRING_CONTAINS, args[0], args[1])
 
     def walk_str_indexof(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.STRING_INDEXOF, args[0], args[1], args[2])
+        return self.cvc5_solver.mkTerm(Kind.STRING_INDEXOF, args[0], args[1], args[2])
 
     def walk_str_replace(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.STRING_REPLACE, args[0], args[1], args[2])
+        return self.cvc5_solver.mkTerm(Kind.STRING_REPLACE, args[0], args[1], args[2])
 
     def walk_str_substr(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.STRING_SUBSTR, args[0], args[1], args[2])
+        return self.cvc5_solver.mkTerm(Kind.STRING_SUBSTR, args[0], args[1], args[2])
 
     def walk_str_prefixof(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.STRING_PREFIX, args[0], args[1])
+        return self.cvc5_solver.mkTerm(Kind.STRING_PREFIX, args[0], args[1])
 
     def walk_str_suffixof(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.STRING_SUFFIX, args[0], args[1])
+        return self.cvc5_solver.mkTerm(Kind.STRING_SUFFIX, args[0], args[1])
 
     def walk_str_to_int(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.STRING_TO_INT, args[0])
+        return self.cvc5_solver.mkTerm(Kind.STRING_TO_INT, args[0])
 
     def walk_int_to_str(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.STRING_FROM_INT, args[0])
+        return self.cvc5_solver.mkTerm(Kind.STRING_FROM_INT, args[0])
 
     def walk_str_charat(self, formula, args, **kwargs):
-        return self.cvc5.mkTerm(Kind.STRING_CHARAT, args[0], args[1])
+        return self.cvc5_solver.mkTerm(Kind.STRING_CHARAT, args[0], args[1])
 
     def _type_to_cvc5(self, tp):
         if tp.is_bool_type():
-            return self.cvc5.getBooleanSort()
+            return self.cvc5_solver.getBooleanSort()
         elif tp.is_real_type():
-            return self.cvc5.getRealSort()
+            return self.cvc5_solver.getRealSort()
         elif tp.is_int_type():
-            return self.cvc5.getIntegerSort()
+            return self.cvc5_solver.getIntegerSort()
         elif tp.is_function_type():
             stps = [self._type_to_cvc5(x) for x in tp.param_types]
             rtp = self._type_to_cvc5(tp.return_type)
-            return self.cvc5.mkFunctionSort(stps, rtp)
+            return self.cvc5_solver.mkFunctionSort(stps, rtp)
         elif tp.is_array_type():
             # Recursively convert the types of index and elem
             idx_cvc_type = self._type_to_cvc5(tp.index_type)
             elem_cvc_type = self._type_to_cvc5(tp.elem_type)
-            return self.cvc5.mkArraySort(idx_cvc_type, elem_cvc_type)
+            return self.cvc5_solver.mkArraySort(idx_cvc_type, elem_cvc_type)
         elif tp.is_bv_type():
-            return self.cvc5.mkBitVectorSort(tp.width)
+            return self.cvc5_solver.mkBitVectorSort(tp.width)
         elif tp.is_string_type():
-            return self.cvc5.getStringSort()
+            return self.cvc5_solver.getStringSort()
         elif tp.is_custom_type():
-            return self.cvc5.mkUninterpretedSort(str(tp))
+            return self.cvc5_solver.mkUninterpretedSort(str(tp))
         else:
             raise NotImplementedError("Unsupported type: %s" %tp)
 
@@ -539,7 +580,7 @@ class CVC5Converter(Converter, DagWalker):
         Returns a tuple (new_formula, new_var_list) in which the old
         variables have been replaced by the new variables in the list.
         """
-        mkBoundVar = self.cvc5.mkVar
+        mkBoundVar = self.cvc5_solver.mkVar
         new_var_list = [mkBoundVar(self._type_to_cvc5(x.symbol_type()),
                                    x.symbol_name())
                         for x in variables]

pysmt/solvers/z3.py

@@ -45,7 +45,8 @@ from pysmt.exceptions import (SolverReturnedUnknownResultError,
                               UndefinedSymbolError, PysmtValueError,
                               PysmtInfinityError, PysmtInfinitesimalError)
 from pysmt.decorators import clear_pending_pop, catch_conversion_error
-from pysmt.logics import LRA, LIA, QF_UFLRA, QF_UFLIA, PYSMT_LOGICS
+from pysmt.logics import LRA, LIA, QF_UFLRA, QF_UFLIA, PYSMT_LOGICS, \
+    AUFLIRA, AUFLIA, AUFNIRA, ALIA
 from pysmt.oracles import get_logic
 from pysmt.constants import Fraction, Numeral, is_pysmt_integer
 
@@ -141,7 +142,9 @@ class Z3Options(SolverOptions):
 class Z3Solver(IncrementalTrackingSolver, UnsatCoreSolver,
                SmtLibBasicSolver, SmtLibIgnoreMixin):
 
-    LOGICS = PYSMT_LOGICS - set(x for x in PYSMT_LOGICS if x.theory.strings)
+    LOGICS = (PYSMT_LOGICS |
+              {AUFLIRA, AUFLIA, AUFNIRA, ALIA}) -\
+             set(x for x in PYSMT_LOGICS if x.theory.strings)
     OptionsClass = Z3Options
 
     SOLVERFOR_LOGIC_NAMES=['AUFLIA', 'ALIA', 'AUFLIRA', 'AUFNIRA', 'LRA', 'LIA', 'NIA',

pysmt/test/smtlib/parser_utils.py

@@ -52,18 +52,18 @@ def execute_script_fname(smtfile, logic, expected_result):
     parser = SmtLibParser()
     script = parser.get_script_fname(smtfile)
     try:
-        solver = Solver(logic=logic, incremental=False,
-                        generate_models=False)
-        if logic == QF_UF and type(solver).__name__ == 'CVC5Solver':
-            warnings.warn("Test (%s, %s) skipped because CVC5 can't handle QF_UF." % (logic, smtfile))
-            return
-        if logic == QF_LIA and type(solver).__name__ == 'CVC5Solver':
-            warnings.warn("Test (%s, %s) skipped because CVC5 is very slow on QF_LIA tests" % (logic, smtfile))
-            return
-        if logic == QF_UF and type(solver).__name__ == 'BoolectorSolver':
-            warnings.warn("Test (%s, %s) skipped because Boolector can't handle QF_UF." % (logic, smtfile))
-            return
-        log = script.evaluate(solver)
+        with Solver(logic=logic, incremental=False,
+                        generate_models=False) as solver:
+            if logic == QF_UF and type(solver).__name__ == 'CVC5Solver':
+                warnings.warn("Test (%s, %s) skipped because CVC5 can't handle QF_UF." % (logic, smtfile))
+                return
+            if logic == QF_LIA and type(solver).__name__ == 'CVC5Solver':
+                warnings.warn("Test (%s, %s) skipped because CVC5 is very slow on QF_LIA tests" % (logic, smtfile))
+                return
+            if logic == QF_UF and type(solver).__name__ == 'BoolectorSolver':
+                warnings.warn("Test (%s, %s) skipped because Boolector can't handle QF_UF." % (logic, smtfile))
+                return
+            log = script.evaluate(solver)
     except NoSolverAvailableError:
         raise SkipTest("No solver for logic %s." % logic)
     except SolverReturnedUnknownResultError:

pysmt/test/test_bdd.py

@@ -167,7 +167,7 @@ class TestBdd(TestCase):
                                     'dynamic_reordering':True}) as s:
             s.add_assertion(self.big_tree)
             self.assertTrue(s.solve())
-            self.assertNotEquals(s.ddmanager.ReorderingStatus()[1], 0)
+            self.assertNotEqual(s.ddmanager.ReorderingStatus()[1], 0)
 
 
 if __name__ == '__main__':

pysmt/test/test_logics.py

@@ -114,9 +114,6 @@ class TestLogic(TestCase):
             with self.assertRaises(NoSolverAvailableError):
                 Solver(logic=pysmt.logics.QF_BOOL)
 
-        with self.assertRaises(NoSolverAvailableError):
-            Solver(logic=NRA)
-
         with self.assertRaises(NoSolverAvailableError):
             Solver(name='picosat', logic=pysmt.logics.QF_BV)
 

{PySMT-0.9.7.dev337.dist-info → pysmt-0.9.7.dev354.dist-info}/METADATA

@@ -1,12 +1,20 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: PySMT
-Version: 0.9.7.dev337
+Version: 0.9.7.dev354
 Summary: A solver-agnostic library for SMT Formulae manipulation and solving
 Home-page: http://www.pysmt.org
 Author: PySMT Team
 Author-email: info@pysmt.org
 License: APACHE
-Platform: UNKNOWN
+License-File: LICENSE
+License-File: NOTICE
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: summary
 
 ============================================================
  pySMT: A library for SMT formulae manipulation and solving
@@ -48,5 +56,3 @@ Wanna know more?
 ================
 
 Visit http://www.pysmt.org
-
-

{PySMT-0.9.7.dev337.dist-info → pysmt-0.9.7.dev354.dist-info}/RECORD

@@ -1,4 +1,4 @@
-pysmt/__init__.py,sha256=4qoWpE_YchHcFrvD6jeWloG3_PgCmssRGEMDiaBtTtY,1598
+pysmt/__init__.py,sha256=uBJ4BYtJu6BmmYf3DQXRU33TOF0WoY4GPIbasdKMLJU,1598
 pysmt/__main__.py,sha256=rR-MV1QtLYqtVoJyY3m5B5Iz-lua0-5o6YSB0W4lKy8,1085
 pysmt/configuration.py,sha256=Iq_46QZ9z_jpBMk76euJWTqGEwHad2qyiEDPix5sXsA,4538
 pysmt/constants.py,sha256=QelM9r5fGWSq8UNjjYoEJK2FaLHRr4Z9NZxzjeajEWA,5249
@@ -22,17 +22,17 @@ pysmt/typing.py,sha256=GioU08mUxqsjFmmAYfBYj51mmJoBcFZDunc-t99QKng,17714
 pysmt/utils.py,sha256=t13jG-E8kQNxG_JmS79GDy3SnBohSobwjJTjZHFf3fE,2302
 pysmt/cmd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pysmt/cmd/check_version.py,sha256=FOumRpuGF1ntqm70QHJqZ6JEKeEamGMY-lp5XOqhPlo,2688
-pysmt/cmd/install.py,sha256=2p5o6hdqnejcNfF4nv0vmoi-wkCdaTCMLu5nL-GU9Hw,10468
+pysmt/cmd/install.py,sha256=DtxqsZRx_qcxLWYpCVfG-Alv774aQT0PbiXC0-aymOk,10468
 pysmt/cmd/shell.py,sha256=7vfFcEYNBueQVeOEW7r38PdEfAdL71xby03BF7XR9ec,6112
 pysmt/cmd/installers/__init__.py,sha256=sJiTL66cCauRGJ6axZMJzSKM8io5DTzbWHaUpggSL1Q,1255
-pysmt/cmd/installers/base.py,sha256=1usHiBHrIBam9BlbVKG-6F52KPsIkJBeghkd_ckh-8U,12811
+pysmt/cmd/installers/base.py,sha256=ajiPGGR2jGEA1ZxMqqh6S2hIPCLHyllbk40tVQeGwDk,13158
 pysmt/cmd/installers/bdd.py,sha256=Qq8YlYAVvxUqNXjoOlH9_Lhj4cj6WEt7HuhbSiF_L6k,2539
 pysmt/cmd/installers/btor.py,sha256=gUl_urKcWtbSYS_Vde_O7RJM0H-kRqh6hceTju-Sbcs,4995
 pysmt/cmd/installers/cvcfive.py,sha256=vWqAm5xF7IMY0JWEeyx3_ochCqyHx0dlcZBo9QcQ-uk,1460
 pysmt/cmd/installers/cvcfour.py,sha256=uBZkKIX4gZEMfjrhrparUSDydMcvGIGZM2Y8JYD0GzE,3916
-pysmt/cmd/installers/msat.py,sha256=hNz7TbqYrEg9I0vvkSaBiKdy4v8RxH8oXGhXQhgNIVU,5409
-pysmt/cmd/installers/optimsat.py,sha256=ijbFb8dl0t4ruzVH1mrgKWWpxvRoN_1ROY4KlvroPv4,3908
-pysmt/cmd/installers/pico.py,sha256=XJpVbY5YHboL3OEMBvjwv8QwKdJ7Y62Blb78tEGyMxU,3141
+pysmt/cmd/installers/msat.py,sha256=PnHNSbMLB99SPCkv2cuK8LyWweJVa7cOOcGvsFTgzsU,5547
+pysmt/cmd/installers/optimsat.py,sha256=wktjIyM47noeT2A9yT1MnghDU4RiZVpVCYK3egWyLv4,3909
+pysmt/cmd/installers/pico.py,sha256=U4sXr1oj4BJJpO5H7vB8WqJ6OEPazpYkmmXP1XWhvys,3027
 pysmt/cmd/installers/yices.py,sha256=M99P641jqGtAWOgQpAQzt4T1KwmSClw1VDEETzsSZe0,3010
 pysmt/cmd/installers/z3.py,sha256=5wP6O-a602-y1cuEyr22bkdWnOWHx8bIaPQ24xDtxX8,1386
 pysmt/optimization/__init__.py,sha256=JXBHtcb4Lv-Sb8whc9JuGbRH2EBLWwtLUh3PL9HhNE8,650
@@ -54,7 +54,7 @@ pysmt/smtlib/parser/parser.py,sha256=jkxVWYKJWtB5Bct_Warif_bgQmiRfPhJNOhWFhl55Iw
 pysmt/solvers/__init__.py,sha256=JXBHtcb4Lv-Sb8whc9JuGbRH2EBLWwtLUh3PL9HhNE8,650
 pysmt/solvers/bdd.py,sha256=my3398_-8Rkqy1pluzZa7_12qsA43ARbs8-YAPqdMWs,15938
 pysmt/solvers/btor.py,sha256=2oT1PfXSGTSTPaXQUwVy0M799slSH2FJ-3QNb3YQmGw,25953
-pysmt/solvers/cvcfive.py,sha256=z8o4VxrZBC6sdb_JYTWfRS3BXdWJPznakN3k7rD4EY8,21073
+pysmt/solvers/cvcfive.py,sha256=Sk0s1MrSGXdgLqPu_I-Xs19nG08e2HpZyeAehF-OE60,23877
 pysmt/solvers/cvcfour.py,sha256=odWm_MAgoPlhOf6gaarZQAqQS4fN-8PH-xGIYaiErQE,24538
 pysmt/solvers/dynmsat.py,sha256=RenEJwWD8qLWECnyq141_0qbw1GGB5uYKvzJ18_Fgbk,1917
 pysmt/solvers/eager.py,sha256=dyUHR6hmBcqn83NR4kFVhrpfneEpb9Uz4llP1fSaYs4,3374
@@ -67,14 +67,14 @@ pysmt/solvers/qelim.py,sha256=Fjy54lbyIKahAzGajhaihXYQyYn97h83Ud2er-zjwcw,4822
 pysmt/solvers/smtlib.py,sha256=6gGq-UdCVrrdmliCNl2RByyn5qMqBtVVDP_sB2jXiQ8,8998
 pysmt/solvers/solver.py,sha256=Me-0lvKcXV5PEL4N0wk2u7R1hGi-6JtlbdFNL-PimzM,17678
 pysmt/solvers/yices.py,sha256=ZU3iqj29oKnqDnDnPnfKvS1QBAGEMecrQgZ14qRsoUQ,24489
-pysmt/solvers/z3.py,sha256=XE388MLsnd5lipftzB5laDy4fOMxUsDBVAp0jX_pUzM,42679
+pysmt/solvers/z3.py,sha256=mG55ZtxnEswPEmEb1HzCmRei4RuTxWEjQBJcX_ejhTY,42782
 pysmt/test/__init__.py,sha256=IwYjp7mgUeozyYHb8D-lRiZKHUJ_srsAiyYttuSWbj0,5492
 pysmt/test/examples.py,sha256=XymEXLmIZxMtS9qTfzrXYbi4DBaMTgPzd_ijKh1H2aM,39485
 pysmt/test/omt_examples.py,sha256=f1DKD3dtxWEsMRFYdj_ZLMR6vezP9rSTzmb83weux0Q,9583
 pysmt/test/optimization_utils.py,sha256=z1z3cbfUbCeExylK1rnsiYR_NJTIUi3Z-OGH3y-7kwg,14266
 pysmt/test/test_array.py,sha256=OypmqKf_ciigxK1X_W2b9sm0EWOA3wqH376QXt7oGCM,6237
 pysmt/test/test_back.py,sha256=3O7XTx4WfuizjT7-yueZq6oGG-uqovkie7R3A5GklTk,3372
-pysmt/test/test_bdd.py,sha256=GsFiq0YQd3exbN9k2fCurKZlvDl3H2VAucYc9tKGKEc,6195
+pysmt/test/test_bdd.py,sha256=CzOzP7CnTvhsg8KT5d8FPNSZ4uO9fI8deU1Xv8YUFIs,6194
 pysmt/test/test_bv.py,sha256=-pnOgslpMAeK9US4f_z4CU8LK0ZmDr-yceS1u1kwgps,12284
 pysmt/test/test_bv_simplification.py,sha256=gbXcSyjM9I9Zxlu5n43a66fW3RomarP2_DEj6IzYQTc,14637
 pysmt/test/test_cnf.py,sha256=Kbfe6-WUv2fWXmVaxFSPi-B4hIO9AvLitZxMySCvfes,4434
@@ -91,7 +91,7 @@ pysmt/test/test_imports.py,sha256=f41EUBrlDItgQ_6SPhWW8-tuwMrdMFXHJzaxrHHB43Q,15
 pysmt/test/test_int.py,sha256=dk72Q6viqRUs9XiPB40n6RrwiqsV6GbbKuSlYaQMU9k,1980
 pysmt/test/test_interpolation.py,sha256=WTodZtnxH5slIvUWbHbjjnI2o0naXgZwZawTGhh3E0o,3941
 pysmt/test/test_lira.py,sha256=1B4y1y2U-5CttF6h22tniJkAedUDIwjp1Ad0_Ha_s-8,2175
-pysmt/test/test_logics.py,sha256=Nppv0G7z0XIE8wHyWI3F04Vy1PY2iMVwvjyDcYBeS8A,6980
+pysmt/test/test_logics.py,sha256=bWwE_7rq9SVcXglE-ugteGeCHXAYFiBdi-QgIL9-9KE,6893
 pysmt/test/test_models.py,sha256=npqGoF-3DgAw0DTx6se32ZEZRFBJDcnkppzgyjLDbps,2748
 pysmt/test/test_native_qe.py,sha256=RGZgwbpAkPBTjIqcCbOkZ_nQXIDZ4Fznrr7Ldx6oA38,3439
 pysmt/test/test_nia.py,sha256=x51d0X5jnZnxTPvPLrlD0WilunZ5uNrDU4vWY78_xpU,6640
@@ -117,7 +117,7 @@ pysmt/test/test_walkers.py,sha256=AKVMvEUtMBht08bE1vCMaeMtdgGa6j_weDSHz_9Br3Q,94
 pysmt/test/configs/config1.ini,sha256=MAXPN6VVW-S7jpWmglMPN5a3JYgorTqKAF6cmfohMpo,224
 pysmt/test/configs/config_bad.ini,sha256=AOiZPmUcmAjVXOd5Bp4_euaYJG8EfccBy5iKUEcbxz8,88
 pysmt/test/smtlib/__init__.py,sha256=JXBHtcb4Lv-Sb8whc9JuGbRH2EBLWwtLUh3PL9HhNE8,650
-pysmt/test/smtlib/parser_utils.py,sha256=8pvCwJ0Ba_yGzC9wRmkuleAkSmdQnvxTm4rM5lD8bkQ,13678
+pysmt/test/smtlib/parser_utils.py,sha256=L3RFUy_z1yqKPhyg1fOeTtEbgi4CDwSmiune865miyo,13725
 pysmt/test/smtlib/test_annotations.py,sha256=Zmj3xvPt10If2_2y39hqJqqXbSK_5X_qmPkLUNgjRA4,6296
 pysmt/test/smtlib/test_fuzzed.py,sha256=pswc1F2ngXMZo-laFOs6pXnDg69JMfGPx1vMTsXdAX0,2124
 pysmt/test/smtlib/test_generic_wrapper.py,sha256=Gn_cWynRWAFqUcAWpRgmJlkkwHcqdnARZN0-blRwM-Q,7869
@@ -143,10 +143,10 @@ pysmt/walkers/dag.py,sha256=pUdVTZx7CQyjrAb6jMfmsqS07J4kiDqHU8R4_9UvwkQ,5352
 pysmt/walkers/generic.py,sha256=q1j1T2RvCeJn1PM0H5d8vNV4FTYAEQgT7h8X5DJhDf8,4534
 pysmt/walkers/identitydag.py,sha256=f_D5qA198ayd3QO4u59fBX1RS_UiSBnPeV9O3ULvQv0,8737
 pysmt/walkers/tree.py,sha256=WIWN9IM0riWkaD40iP4Tt3BCN21iSdE1S7gRZqy56SU,2846
-PySMT-0.9.7.dev337.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-PySMT-0.9.7.dev337.dist-info/METADATA,sha256=llt-p3vZt1Ly6hCzRAlptfBz9gO3Bu2uXR4_kemWylE,1617
-PySMT-0.9.7.dev337.dist-info/NOTICE,sha256=Ns-Jsa6nbqZUiTEEAM6HqioSZIxQ2RCJzxoBlWQaUfc,601
-PySMT-0.9.7.dev337.dist-info/WHEEL,sha256=Kh9pAotZVRFj97E15yTA4iADqXdQfIVTHcNaZTjxeGM,110
-PySMT-0.9.7.dev337.dist-info/entry_points.txt,sha256=si0hIk-v3V35G3p8QGINoQ4QW-v4RYDRqj-asgyCgeM,58
-PySMT-0.9.7.dev337.dist-info/top_level.txt,sha256=NwHQbpTaZMEvjIUdC0bvvj-WUyULe-nt-opK3YQNRMk,6
-PySMT-0.9.7.dev337.dist-info/RECORD,,
+pysmt-0.9.7.dev354.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+pysmt-0.9.7.dev354.dist-info/licenses/NOTICE,sha256=Ns-Jsa6nbqZUiTEEAM6HqioSZIxQ2RCJzxoBlWQaUfc,601
+pysmt-0.9.7.dev354.dist-info/METADATA,sha256=aN86-wbV_Ecv0rIdVX-I91h9MQmxn-z5IDS-3jxAl-c,1774
+pysmt-0.9.7.dev354.dist-info/WHEEL,sha256=TdQ5LtNwLuxTCjgxN51AgdU5w-KkB9ttmLbzjTH02pg,109
+pysmt-0.9.7.dev354.dist-info/entry_points.txt,sha256=gDc1XM0xTJJMDGC_nXd0kfbX-Omjke9Dn9F3awMLYIU,57
+pysmt-0.9.7.dev354.dist-info/top_level.txt,sha256=NwHQbpTaZMEvjIUdC0bvvj-WUyULe-nt-opK3YQNRMk,6
+pysmt-0.9.7.dev354.dist-info/RECORD,,

{PySMT-0.9.7.dev337.dist-info → pysmt-0.9.7.dev354.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.45.1)
+Generator: setuptools (82.0.1)
 Root-Is-Purelib: true
 Tag: py2-none-any
 Tag: py3-none-any

{PySMT-0.9.7.dev337.dist-info → pysmt-0.9.7.dev354.dist-info}/entry_points.txt

@@ -1,3 +1,2 @@
 [console_scripts]
 pysmt-install = pysmt.cmd.install:main
-