PySMT 0.9.7.dev356__py2.py3-none-any.whl → 0.9.7.dev397__py2.py3-none-any.whl

pysmt/__init__.py

@@ -16,7 +16,10 @@
 #   limitations under the License.
 #
 
-VERSION = (0, 9, 7, "dev", 356)
+from typing import Tuple, Union
+
+
+VERSION: Union[Tuple[int, int, int], Tuple[int, int, int, str, int]] = (0, 9, 7, "dev", 397)
 
 # Try to provide human-readable version of latest commit for dev versions
 # E.g. v0.5.1-4-g49a49f2-wip
@@ -32,8 +35,8 @@ if len(VERSION) == 5:
                                               stderr=subprocess.STDOUT)
         commits_from_tag = git_version.strip().decode('ascii')
         commits_from_tag = commits_from_tag.split("-")[1]
-        commits_from_tag = int(commits_from_tag)
-        VERSION = VERSION[:4] + (commits_from_tag,)
+        commits_from_tag_int = int(commits_from_tag)
+        VERSION = VERSION[:4] + (commits_from_tag_int,)
     except Exception as ex:
         pass
 

pysmt/cmd/check_version.py

@@ -19,16 +19,16 @@ import re
 def check_version(module):
     try:
         if module == "z3":
-            import z3
+            import z3 # type: ignore[import]
             (major, minor, ver, _) = z3.get_version()
             version = "%d.%d.%d" % (major, minor, ver)
 
         elif module in ("msat", "optimsat"):
             if module == "msat":
-                import mathsat
+                import mathsat # type: ignore[import]
                 version_str = mathsat.msat_get_version()
             else:
-                import optimathsat
+                import optimathsat # type: ignore[import]
                 version_str = optimathsat.msat_get_version()
             m = re.match(r"^MathSAT5 version (\d+\.\d+\.\d+) .*$", version_str)
             if m is not None:
@@ -39,31 +39,31 @@ def check_version(module):
                     version = m.group(1)
 
         elif module == "cudd":
-            import repycudd
+            import repycudd # type: ignore[import]
             doc = repycudd.DOCSTRING
             m = re.match(r"^PyCUDD (\d+\.\d+\.\d+).*", doc)
             if m is not None:
                 version = m.group(1)
 
         elif module == "btor":
-            import pyboolector
+            import pyboolector # type: ignore[import]
             version = "OK" # Just checking if import succeeds
 
         elif module == "cvc5":
-            import cvc5
+            import cvc5 # type: ignore[import]
             solver = cvc5.Solver()
             version = solver.getVersion().decode('ascii')
 
         elif module == "cvc4":
-            import CVC4
+            import CVC4 # type: ignore[import]
             version = CVC4.Configuration_getVersionString()
 
         elif module == "picosat":
-            import picosat
+            import picosat # type: ignore[import]
             version = picosat.picosat_version()
 
         elif module == "yices":
-            import yices_api
+            import yices_api # type: ignore[import]
             version = yices_api.yices_python_version
         else:
             print("Invalid argument '%s'"  % module)

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/cmd/installers/__init__.py

@@ -22,6 +22,7 @@ from pysmt.cmd.installers.pico import PicoSATInstaller
 from pysmt.cmd.installers.bdd import CuddInstaller
 from pysmt.cmd.installers.optimsat import OptiMSatInstaller
 
-assert MSatInstaller and Z3Installer and CVC5Installer and YicesInstaller
-assert BtorInstaller and PicoSATInstaller and CuddInstaller and CVC4Installer
-assert OptiMSatInstaller
+# asserts to use the imported variables. Done to avoid the unused variables warning
+assert MSatInstaller and Z3Installer and CVC5Installer and YicesInstaller # type: ignore [truthy-function]
+assert BtorInstaller and PicoSATInstaller and CuddInstaller and CVC4Installer # type: ignore [truthy-function]
+assert OptiMSatInstaller # type: ignore [truthy-function]

pysmt/cmd/installers/base.py

@@ -23,6 +23,7 @@ import urllib.request
 
 from contextlib import contextmanager
 from setuptools import Distribution
+from typing import Optional
 
 from urllib.error import HTTPError, URLError
 
@@ -40,7 +41,7 @@ def TemporaryPath(path):
 
 class SolverInstaller(object):
 
-    SOLVER = None
+    SOLVER: Optional[str] = None
 
     def __init__(self, install_dir, bindings_dir, solver_version,
                  archive_name=None, native_link=None, mirror_link=None):

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/cmd/shell.py

@@ -20,15 +20,20 @@
 import sys
 import argparse
 from warnings import warn
+from io import StringIO
+from typing import Any, List
 
+import pysmt.solvers
 from pysmt import __version__
 from pysmt.shortcuts import *
-from pysmt.typing import INT, REAL, BOOL, BVType, BV32
-
+from pysmt.logics import PYSMT_LOGICS
 from pysmt.smtlib.parser import SmtLibParser
-from pysmt.smtlib.script import InterpreterOMT, InterpreterSMT
+from pysmt.smtlib.script import SmtLibCommand, InterpreterOMT, InterpreterSMT
 from pysmt.smtlib.commands import CHECK_SAT, GET_VALUE, GET_OBJECTIVES, ECHO
-from pysmt.logics import PYSMT_LOGICS
+from pysmt.solvers.smtlib import SmtLibSolver
+from pysmt.typing import INT, REAL, BOOL, BVType, BV32
+# assert done to use variables for handier export
+assert INT or REAL or BOOL or BVType or BV32 # type: ignore[truthy-function]
 
 welcome_msg = \
 """Welcome to pySMT!!!
@@ -58,7 +63,7 @@ Happy Solving!
 
 class PysmtShell(object):
 
-    def __init__(self, argv):
+    def __init__(self, argv: List[str]):
         self.env = get_env()
         self.solvers = list(self.env.factory.all_solvers().keys())
         self.optimizers = list(self.env.factory.all_optimizers().keys())
@@ -66,7 +71,7 @@ class PysmtShell(object):
         self.args = self.parser.parse_args(argv)
 
 
-    def get_parser(self):
+    def get_parser(self) ->     argparse.ArgumentParser:
         parser = argparse.ArgumentParser(description="Command-line interface " \
                                          "for pySMT problems")
         parser.add_argument('--version', action='version',
@@ -97,7 +102,7 @@ class PysmtShell(object):
         # Enable infix notation in Interactive mode
         get_env().enable_infix_notation = True
         try:
-            import IPython
+            import IPython # type: ignore
             print(welcome_msg)
             IPython.embed()
         except ImportError:
@@ -105,13 +110,13 @@ class PysmtShell(object):
             code.interact(welcome_msg)
 
 
-    def _print(self, val, stream_out):
+    def _print(self, val: str, stream_out: StringIO):
         stream_out.write(val)
         stream_out.write("\n")
         stream_out.flush()
 
 
-    def print_result(self, stream_out, cmd, result):
+    def print_result(self, stream_out: StringIO, cmd: SmtLibCommand, result: Any):
         name, _ = cmd
         if name == ECHO:
             self._print(result, stream_out)
@@ -132,7 +137,7 @@ class PysmtShell(object):
             self._print(")", stream_out)
 
 
-    def smtlib_solver(self, stream_in, stream_out):
+    def smtlib_solver(self, stream_in: StringIO, stream_out: StringIO):
         smt_parser = SmtLibParser()
         s_name = self.args.solver
         opt_name = self.args.optimizer
@@ -142,10 +147,10 @@ class PysmtShell(object):
 
         if opt_name is not None:
             if opt_name == "auto":
-                solver = Optimizer(logic=logic)
+                solver: "pysmt.solvers.solver.Solver" = Optimizer(logic=logic)
             else:
                 solver = Optimizer(name=opt_name, logic=logic)
-            inter = InterpreterOMT()
+            inter: InterpreterSMT = InterpreterOMT()
         else:
             if s_name == "auto":
                 solver = Solver(logic=logic)
@@ -153,6 +158,7 @@ class PysmtShell(object):
                 solver = Solver(name=s_name, logic=logic)
             inter = InterpreterSMT()
         for cmd in smt_parser.get_command_generator(stream_in):
+            assert isinstance(solver, SmtLibSolver)
             r = inter.evaluate(cmd, solver)
             self.print_result(stream_out, cmd, r)
 

pysmt/constants.py

@@ -16,7 +16,10 @@
 
 import os
 
+from typing import Any, Optional, Type, Union, cast
+
 from pysmt.exceptions import PysmtImportError
+
 # The environment variable can be used to force the configuration
 # of the Fraction class.
 #
@@ -29,13 +32,14 @@ from pysmt.exceptions import PysmtImportError
 # If set to True, Python's Fraction module will be used instead.
 #
 
-ENV_USE_GMPY = os.environ.get("PYSMT_GMPY")
-if ENV_USE_GMPY is not None:
-    ENV_USE_GMPY = ENV_USE_GMPY.lower() in ["true", "1"]
+ENV_USE_GMPY: Optional[bool] = None
+env_use_gmpy_val = os.environ.get("PYSMT_GMPY")
+if env_use_gmpy_val is not None:
+    ENV_USE_GMPY = env_use_gmpy_val.lower() in ["true", "1"]
 
 HAS_GMPY = False
 try:
-    from gmpy2 import mpq, mpz
+    from gmpy2 import mpq, mpz # type: ignore[import]
     HAS_GMPY = True
 except ImportError as ex:
     if ENV_USE_GMPY is True:
@@ -52,8 +56,8 @@ else:
     USE_GMPY = HAS_GMPY
 
 if HAS_GMPY:
-    mpq_type = type(mpq(1,2))
-    mpz_type = type(mpz(1))
+    mpq_type: Optional[Type[Any]] = type(mpq(1,2))
+    mpz_type: Optional[Type[Any]] = type(mpz(1))
 else:
     mpq_type = None
     mpz_type = None
@@ -67,10 +71,11 @@ if USE_GMPY:
     Fraction = mpq
 else:
     Fraction = pyFraction
+
 FractionClass = type(Fraction(1,2))
 
 
-def is_pysmt_fraction(var):
+def is_pysmt_fraction(var: Any) -> bool:
     """Tests whether var is a Fraction.
 
     This takes into account the class being used to represent the Fraction.
@@ -87,7 +92,7 @@ else:
 IntegerClass = type(Integer(1))
 
 
-def is_pysmt_integer(var):
+def is_pysmt_integer(var: Any) -> bool:
     """Tests whether var is an Integer.
 
     This takes into account the class being used to represent the Integer.
@@ -95,7 +100,7 @@ def is_pysmt_integer(var):
     return type(var) == IntegerClass
 
 
-def is_python_integer(var):
+def is_python_integer(var: Any) -> bool:
     """Checks whether var is Python Integer.
 
     This accounts for: long, int and mpz (if available).
@@ -107,7 +112,7 @@ def is_python_integer(var):
     return False
 
 
-def is_python_rational(var):
+def is_python_rational(var: Any) -> bool:
     """Tests whether var is a Rational.
 
     This accounts for: long, int, float, Fraction, mpz, mpq (if available).
@@ -123,7 +128,7 @@ def is_python_rational(var):
     return False
 
 
-def is_python_boolean(var):
+def is_python_boolean(var: Any):
     """Tests whether var is a Boolean."""
     return var is True or var is False
 
@@ -142,28 +147,29 @@ def to_python_integer(value):
 
 
 if USE_GMPY:
-    def pysmt_fraction_from_rational(value):
+    def pysmt_fraction_from_rational(value: Union[float, int, pyFraction]) -> pyFraction:
         """Return a pysmt Fraction for the rational value."""
         if type(value) == FractionClass:
             # Nothing to do
-            return value
-        return Fraction(value)
+            return cast(pyFraction, value)
+        return cast(pyFraction, FractionClass(value))
 else:
-    def pysmt_fraction_from_rational(value):
+    def pysmt_fraction_from_rational(value: Union[float, int, pyFraction]) -> pyFraction:
         """Return a pysmt Fraction for the rational value."""
         if type(value) == FractionClass:
             # Nothing to do
-            return value
+            return cast(pyFraction, value)
         # Python's Fraction is a bit picky, need to
         # construct the object in different ways
         if type(value) == mpq_type:
-            n = Integer(value.numerator())
-            d = Integer(value.denominator())
-            return Fraction(n, d)
+            val = cast(Any, value)
+            n = Integer(val.numerator())
+            d = Integer(val.denominator())
+            return cast(pyFraction, Fraction(n, d))
         elif type(value) == mpz_type:
-            return Fraction(Integer(value))
+            return cast(pyFraction, Fraction(Integer(value)))
         else:
-            return Fraction(value)
+            return cast(pyFraction, Fraction(value))
 
 #
 # Algebraic Numbers Using Z3
@@ -171,7 +177,7 @@ else:
 
 USE_Z3 = False
 try:
-    import z3.z3num
+    import z3.z3num # type: ignore[import]
     USE_Z3 = True
 except ImportError:
     pass
@@ -192,7 +198,7 @@ if USE_Z3:
             pass
 
 else:
-    class Numeral(object):
+    class Numeral(object): # type: ignore[no-redef]
         """Represents a Number (Algebraic)"""
         def __init__(self, obj):
             raise NotImplementedError("Z3 is not installed. "\
@@ -201,5 +207,5 @@ else:
 #
 # Strings
 #
-def is_python_string(str1):
+def is_python_string(str1: str) -> bool:
     return type(str1) == str

pysmt/decorators.py

@@ -19,16 +19,17 @@ from functools import wraps
 import warnings
 
 import pysmt.exceptions
+from typing import Callable, Optional
 
 class deprecated(object):
     """This is a decorator which can be used to mark functions
     as deprecated. It will result in a warning being emitted
     when the function is used."""
 
-    def __init__(self, alternative=None):
+    def __init__(self, alternative: Optional[str]=None):
         self.alternative = alternative
 
-    def __call__(self, func):
+    def __call__(self, func: Callable) -> Callable:
         def newFunc(*args, **kwargs):
             alt = ""
             if self.alternative is not None:
@@ -44,7 +45,7 @@ class deprecated(object):
         return newFunc
 
 
-def clear_pending_pop(f):
+def clear_pending_pop(f: Callable) -> Callable:
     """Pop the solver stack (if necessary) before calling the function.
 
     Some functions (e.g., get_value) required the state of the solver
@@ -75,7 +76,7 @@ def typecheck_result(f):
     return typecheck_result_wrap
 
 
-def catch_conversion_error(f):
+def catch_conversion_error(f: Callable) -> Callable:
     """Catch unknown operators errors and converts them into conversion error."""
 
     @wraps(f)
@@ -92,7 +93,7 @@ def catch_conversion_error(f):
     return catch_conversion_error_wrap
 
 
-def assert_infix_enabled(f):
+def assert_infix_enabled(f: Callable) -> Callable:
     """Raise an exception if infix notation is not enabled."""
     from functools import wraps
     from pysmt.exceptions import PysmtModeError

pysmt/environment.py

@@ -21,14 +21,14 @@ singleton objects that are used throughout the system, such as the
 FormulaManager, Simplifier, HRSerializer, SimpleTypeChecker.
 """
 
+from typing import List, Optional
+
 import pysmt.simplifier
 import pysmt.printers
 import pysmt.substituter
 import pysmt.type_checker
 import pysmt.oracles
 import pysmt.formula
-import pysmt.factory
-import pysmt.decorators
 import pysmt.typing
 
 
@@ -41,11 +41,12 @@ class Environment(object):
     of classes for the different services, by changing the class
     attributes.
     """
+
     TypeCheckerClass = pysmt.type_checker.SimpleTypeChecker
     FormulaManagerClass = pysmt.formula.FormulaManager
     TypeManagerClass = pysmt.typing.TypeManager
     SimplifierClass = pysmt.simplifier.Simplifier
-    #SubstituterClass = pysmt.substituter.MSSubstituter
+    # SubstituterClass = pysmt.substituter.MSSubstituter
     SubstituterClass = pysmt.substituter.MGSubstituter
     HRSerializerClass = pysmt.printers.HRSerializer
     QuantifierOracleClass = pysmt.oracles.QuantifierOracle
@@ -91,57 +92,57 @@ class Environment(object):
         self.dwf = {}
 
     @property
-    def formula_manager(self):
+    def formula_manager(self) -> pysmt.formula.FormulaManager:
         return self._formula_manager
 
     @property
-    def type_manager(self):
+    def type_manager(self) -> pysmt.typing.TypeManager:
         return self._type_manager
 
     @property
-    def simplifier(self):
+    def simplifier(self) -> pysmt.simplifier.Simplifier:
         return self._simplifier
 
     @property
-    def serializer(self):
+    def serializer(self) -> pysmt.printers.HRSerializer:
         return self._serializer
 
     @property
-    def substituter(self):
+    def substituter(self) -> pysmt.substituter.Substituter:
         return self._substituter
 
     @property
-    def stc(self):
+    def stc(self) -> pysmt.type_checker.SimpleTypeChecker:
         """ Get the Simple Type Checker """
         return self._stc
 
     @property
-    def qfo(self):
+    def qfo(self) -> pysmt.oracles.QuantifierOracle:
         """ Get the Quantifier Oracle """
         return self._qfo
 
     @property
-    def ao(self):
+    def ao(self) -> pysmt.oracles.AtomsOracle:
         """ Get the Atoms Oracle """
         return self._ao
 
     @property
-    def theoryo(self):
+    def theoryo(self) -> pysmt.oracles.TheoryOracle:
         """ Get the Theory Oracle """
         return self._theoryo
 
     @property
-    def typeso(self):
+    def typeso(self) -> pysmt.oracles.TypesOracle:
         """ Get the Types Oracle """
         return self._typeso
 
     @property
-    def fvo(self):
+    def fvo(self) -> pysmt.oracles.FreeVarsOracle:
         """ Get the FreeVars Oracle """
         return self._fvo
 
     @property
-    def sizeo(self):
+    def sizeo(self) -> pysmt.oracles.SizeOracle:
         """ Get the Size Oracle """
         return self._sizeo
 
@@ -164,12 +165,13 @@ class Environment(object):
         self.dwf[nodetype][walker] = function
 
     @property
-    def factory(self):
+    def factory(self) -> "pysmt.factory.Factory":
+        import pysmt.factory
         if self._factory is None:
             self._factory = pysmt.factory.Factory(self)
         return self._factory
 
-    def __enter__(self):
+    def __enter__(self) -> "Environment":
         """Entering a Context """
         push_env(self)
         return self
@@ -181,23 +183,26 @@ class Environment(object):
 # EOC Environment
 
 #### GLOBAL ENVIRONMENTS STACKS ####
-ENVIRONMENTS_STACK = []
+ENVIRONMENTS_STACK: List[Environment] = []
 
-def get_env():
+def get_env() -> Environment:
     """Returns the Environment at the head of the stack."""
     return ENVIRONMENTS_STACK[-1]
 
-def push_env(env=None):
+
+def push_env(env: Optional[Environment] = None):
     """Push a env in the stack. If env is None, a new Environment is created."""
     if env is None:
         env = Environment()
     ENVIRONMENTS_STACK.append(env)
 
-def pop_env():
+
+def pop_env() -> Environment:
     """Pop an env from the stack."""
     return ENVIRONMENTS_STACK.pop()
 
-def reset_env():
+
+def reset_env() -> Environment:
     """Destroys and recreate the head environment."""
     pop_env()
     push_env()

pysmt/exceptions.py

@@ -18,6 +18,7 @@
 """This module contains all custom exceptions of pySMT."""
 
 import pysmt.operators as op
+from typing import Optional, Tuple
 
 
 class PysmtException(Exception):
@@ -134,7 +135,7 @@ class PysmtTypeError(PysmtException, TypeError):
     pass
 
 class PysmtSyntaxError(PysmtException, SyntaxError):
-    def __init__(self, message, pos_info=None):
+    def __init__(self, message: str, pos_info: Optional[Tuple[int, int]]=None):
         super(PysmtSyntaxError, self).__init__(message)
         self.pos_info = pos_info
         self.message = message