python-sat 1.8.dev19__tar.gz → 1.8.dev20__tar.gz

{python_sat-1.8.dev19/python_sat.egg-info → python_sat-1.8.dev20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-sat
-Version: 1.8.dev19
+Version: 1.8.dev20
 Summary: A Python library for prototyping with SAT oracles
 Home-page: https://github.com/pysathq/pysat
 Author: Alexey Ignatiev, Joao Marques-Silva, Antonio Morgado

{python_sat-1.8.dev19 → python_sat-1.8.dev20}/pysat/__init__.py

@@ -10,7 +10,7 @@
 
 # current version
 #==============================================================================
-VERSION = (1, 8, 'dev', 19)
+VERSION = (1, 8, 'dev', 20)
 
 
 # PEP440 Format

{python_sat-1.8.dev19 → python_sat-1.8.dev20}/pysat/_fileio.py

@@ -22,11 +22,12 @@
     Module description
     ==================
 
-    This simple module provides a basic interface to input/output operations on
-    files. Its key design feature is the ability to work with both uncompressed
-    and compressed files through a unified interface, thus, making it easier
-    for a user to deal with various types of compressed files. The compression
-    types supported include gzip, bzip2, and lzma (xz).
+    This simple module provides a basic interface to input/output operations
+    on files. Its key design feature is the ability to work with both
+    uncompressed and compressed files through a unified interface, thus,
+    making it easier for a user to deal with various types of compressed
+    files. The compression types supported include gzip, bzip2, lzma (xz), and
+    zstandard (zstd).
 
     The module is supposed to be mainly used by :mod:`pysat.formula`.
 
@@ -66,6 +67,13 @@ except ImportError:
     except ImportError:  # for Python2 without lzma
         lzma_present = False
 
+zstd_present = True
+try:
+    from compression import zstd
+except ImportError:  # zstandard is introduced in Python 3.14
+    zstd_present = False
+
+
 
 #
 #==============================================================================
@@ -75,9 +83,10 @@ class FileObject(object):
         open files creating standard file pointers and closing them. The class
         is used when opening DIMACS files for reading and writing. Supports
         both uncompressed and compressed files. Compression algorithms
-        supported are ``gzip``, ``bzip2``, and ``lzma``. Algorithm ``lzma`` can
-        be used in Python 3 by default and also in Python 2 if the
-        ``backports.lzma`` package is installed.
+        supported are ``gzip``, ``bzip2``, ``lzma``, and ``zstd``. Algorithm
+        ``lzma`` can be used in Python 3 by default and also in Python 2 if
+        the ``backports.lzma`` package is installed. Algorithm ``zstandard``
+        can be used in Python 3.14 and later.
 
         Note that the class opens a file in text mode.
 
@@ -90,8 +99,9 @@ class FileObject(object):
         :type compression: str
 
         Compression type can be ``None``, ``'gzip'``, ``'bzip2'``, ``'lzma'``,
-        as well as ``'use_ext'``. If ``'use_ext'`` is specified, compression
-        algorithm is defined by the extension of the given file name.
+        ``'zstd'``, as well as ``'use_ext'``. If ``'use_ext'`` is specified,
+        compression algorithm is defined by the extension of the given file
+        name.
     """
 
     def __init__(self, name, mode='r', compression=None):
@@ -109,9 +119,9 @@ class FileObject(object):
 
     def open(self, name, mode='r', compression=None):
         """
-            Open a file pointer. Note that a file is *always* opened in text
-            mode. The method inherits its input parameters from the constructor
-            of :class:`FileObject`.
+            Open a file pointer. Note that a file is *always* opened in
+            text mode. The method inherits its input parameters from the
+            constructor of :class:`FileObject`.
         """
 
         if compression == 'use_ext':
@@ -138,11 +148,15 @@ class FileObject(object):
                     self.fp = codecs.getreader('ascii')(self.fp_extra)
                 else:  # mode == 'w'
                     self.fp = codecs.getwriter('ascii')(self.fp_extra)
-        else:  # self.ctype == 'lzma'
+        elif self.ctype == 'lzma':
             # LZMA is available in Python 2 only if backports.lzma is installed
             # Python 3 supports it by default
             assert lzma_present, 'LZMA compression is unavailable.'
             self.fp = lzma.open(name, mode=mode + 't')
+        else:  # self.ctype == 'zstd'
+            # Zstandard is available only in Python 3.14 and later
+            assert zstd_present, 'Zstandard compression is unavailable.'
+            self.fp = zstd.open(name, mode=mode + 't')
 
     def close(self):
         """
@@ -175,6 +189,8 @@ class FileObject(object):
             self.ctype = 'bzip2'
         elif ext in ('.xz', '.lzma'):
             self.ctype = 'lzma'
+        elif ext == 'zst':
+            self.ctype = 'zstd'
         else:
             self.ctype = None
 

{python_sat-1.8.dev19 → python_sat-1.8.dev20}/pysat/formula.py

@@ -1170,7 +1170,7 @@ class Formula(object):
         self.clausify()
 
         # then recursively iterate through the clauses
-        for cl in self._iter(outermost=True):
+        for cl in self._iter({}, outermost=True):
             if PYSAT_TRUE.name not in cl:
                 yield [l for l in cl if l != PYSAT_FALSE.name]
 
@@ -1421,16 +1421,19 @@ class Atom(Formula):
         self.encoded = []  # always empty
         self.object = None
 
-    def _iter(self, outermost=False):
+    def _iter(self, seen, outermost=False):
         """
             Internal iterator over the clauses. Does nothing as there are no
             clauses to iterate through.
         """
 
-        if outermost:
-            yield from self.clauses
-        else:
-            yield from self.encoded
+        if not self in seen:
+            seen[self] = True
+
+            if outermost:
+                yield from self.clauses
+            else:
+                yield from self.encoded
 
     def _clausify(self, name_required=True):
         """
@@ -1602,20 +1605,23 @@ class And(Formula):
         self.encoded = []
         self.subformulas = []
 
-    def _iter(self, outermost=False):
+    def _iter(self, seen, outermost=False):
         """
             Internal iterator over the clauses. First, iterates through the
             clauses of the subformulas followed by the formula's own clauses.
         """
 
-        for sub in self.subformulas:
-            for cl in sub._iter():
-                yield cl
+        if not self in seen:
+            seen[self] = True
 
-        if outermost:
-            yield from self.clauses
-        else:
-            yield from self.encoded
+            for sub in self.subformulas:
+                for cl in sub._iter(seen):
+                    yield cl
+
+            if outermost:
+                yield from self.clauses
+            else:
+                yield from self.encoded
 
     def simplified(self, assumptions=[]):
         """
@@ -1835,20 +1841,23 @@ class Or(Formula):
         self.encoded = []
         self.subformulas = []
 
-    def _iter(self, outermost=False):
+    def _iter(self, seen, outermost=False):
         """
             Internal iterator over the clauses. First, iterates through the
             clauses of the subformulas followed by the formula's own clauses.
         """
 
-        for sub in self.subformulas:
-            for cl in sub._iter():
-                yield cl
+        if not self in seen:
+            seen[self] = True
 
-        if outermost:
-            yield from self.clauses
-        else:
-            yield from self.encoded
+            for sub in self.subformulas:
+                for cl in sub._iter(seen):
+                    yield cl
+
+            if outermost:
+                yield from self.clauses
+            else:
+                yield from self.encoded
 
     def simplified(self, assumptions=[]):
         """
@@ -2031,18 +2040,21 @@ class Neg(Formula):
         self.encoded = []
         self.subformula = None
 
-    def _iter(self, outermost=False):
+    def _iter(self, seen, outermost=False):
         """
             Recursive iterator through the clauses.
         """
 
-        for cl in self.subformula._iter():
-            yield cl
+        if not self in seen:
+            seen[self] = True
 
-        if outermost:
-            yield from self.clauses
-        else:
-            yield from self.encoded
+            for cl in self.subformula._iter(seen):
+                yield cl
+
+            if outermost:
+                yield from self.clauses
+            else:
+                yield from self.encoded
 
     def simplified(self, assumptions=[]):
         """
@@ -2198,21 +2210,24 @@ class Implies(Formula):
         self.encoded = []
         self.left = self.right = None
 
-    def _iter(self, outermost=False):
+    def _iter(self, seen, outermost=False):
         """
             Clause iterator. Recursively iterates through the clauses of
             ``left`` and ``right`` subformulas followed by own clause
             traversal.
         """
 
-        for sub in [self.left, self.right]:
-            for cl in sub._iter():
-                yield cl
+        if not self in seen:
+            seen[self] = True
 
-        if outermost:
-            yield from self.clauses
-        else:
-            yield from self.encoded
+            for sub in [self.left, self.right]:
+                for cl in sub._iter(seen):
+                    yield cl
+
+            if outermost:
+                yield from self.clauses
+            else:
+                yield from self.encoded
 
     def simplified(self, assumptions=[]):
         """
@@ -2421,20 +2436,23 @@ class Equals(Formula):
         self.encoded = []
         self.subformulas = []
 
-    def _iter(self, outermost=False):
+    def _iter(self, seen, outermost=False):
         """
             Internal iterator over the clauses. First, iterates through the
             clauses of the subformulas followed by the formula's own clauses.
         """
 
-        for sub in self.subformulas:
-            for cl in sub._iter():
-                yield cl
+        if not self in seen:
+            seen[self] = True
 
-        if outermost:
-            yield from self.clauses
-        else:
-            yield from self.encoded
+            for sub in self.subformulas:
+                for cl in sub._iter(seen):
+                    yield cl
+
+            if outermost:
+                yield from self.clauses
+            else:
+                yield from self.encoded
 
     def simplified(self, assumptions=[]):
         """
@@ -2679,20 +2697,23 @@ class XOr(Formula):
         self.encoded = []
         self.subformulas = []
 
-    def _iter(self, outermost=False):
+    def _iter(self, seen, outermost=False):
         """
             Internal iterator over the clauses. First, iterates through the
             clauses of the subformulas followed by the formula's own clauses.
         """
 
-        for sub in self.subformulas:
-            for cl in sub._iter():
-                yield cl
+        if not self in seen:
+            seen[self] = True
 
-        if outermost:
-            yield from self.clauses
-        else:
-            yield from self.encoded
+            for sub in self.subformulas:
+                for cl in sub._iter(seen):
+                    yield cl
+
+            if outermost:
+                yield from self.clauses
+            else:
+                yield from self.encoded
 
     def simplified(self, assumptions=[]):
         """
@@ -2945,20 +2966,23 @@ class ITE(Formula):
         self.encoded = []
         self.cond = self.cons1 = self.cons2 = None
 
-    def _iter(self, outermost=False):
+    def _iter(self, seen, outermost=False):
         """
             Internal iterator over the clauses. First, iterates through the
             clauses of the subformulas followed by the formula's own clauses.
         """
 
-        for sub in [self.cond, self.cons1, self.cons2]:
-            for cl in sub._iter():
-                yield cl
+        if not self in seen:
+            seen[self] = True
 
-        if outermost:
-            yield from self.clauses
-        else:
-            yield from self.encoded
+            for sub in [self.cond, self.cons1, self.cons2]:
+                for cl in sub._iter(seen):
+                    yield cl
+
+            if outermost:
+                yield from self.clauses
+            else:
+                yield from self.encoded
 
     def simplified(self, assumptions=[]):
         """
@@ -3180,7 +3204,7 @@ class CNF(Formula, object):
             Read a CNF formula from a file in the DIMACS format. A file name is
             expected as an argument. A default argument is ``comment_lead`` for
             parsing comment lines. A given file can be compressed by either
-            gzip, bzip2, or lzma.
+            gzip, bzip2, lzma, or zstd.
 
             :param fname: name of a file to parse.
             :param comment_lead: a list of characters leading comment lines
@@ -3191,11 +3215,12 @@ class CNF(Formula, object):
             :type compressed_with: str
 
             Note that the ``compressed_with`` parameter can be ``None`` (i.e.
-            the file is uncompressed), ``'gzip'``, ``'bzip2'``, ``'lzma'``, or
-            ``'use_ext'``. The latter value indicates that compression type
-            should be automatically determined based on the file extension.
-            Using ``'lzma'`` in Python 2 requires the ``backports.lzma``
-            package to be additionally installed.
+            the file is uncompressed), ``'gzip'``, ``'bzip2'``, ``'lzma'``,
+            ``'zstd'``, or ``'use_ext'``. The latter value indicates that
+            compression type should be automatically determined based on the
+            file extension. Using ``'lzma'`` in Python 2 requires the
+            ``backports.lzma`` package to be additionally installed. Using
+            ``'zstd'`` requires Python 3.14.
 
             Usage example:
 
@@ -3413,7 +3438,7 @@ class CNF(Formula, object):
             CNF format. A file name is expected as an argument. Additionally,
             supplementary comment lines can be specified in the ``comments``
             parameter. Also, a file can be compressed using either gzip, bzip2,
-            or lzma (xz).
+            lzma (xz), or zstd.
 
             :param fname: a file name where to store the formula.
             :param comments: additional comments to put in the file.
@@ -3425,12 +3450,13 @@ class CNF(Formula, object):
             :type as_dnf: bool
             :type compress_with: str
 
-            Note that the ``compress_with`` parameter can be ``None`` (i.e.
-            the file is uncompressed), ``'gzip'``, ``'bzip2'``, ``'lzma'``, or
-            ``'use_ext'``. The latter value indicates that compression type
-            should be automatically determined based on the file extension.
-            Using ``'lzma'`` in Python 2 requires the ``backports.lzma``
-            package to be additionally installed.
+            Note that the ``compressed_with`` parameter can be ``None`` (i.e.
+            the file is uncompressed), ``'gzip'``, ``'bzip2'``, ``'lzma'``,
+            ``'zstd'``, or ``'use_ext'``. The latter value indicates that
+            compression type should be automatically determined based on the
+            file extension. Using ``'lzma'`` in Python 2 requires the
+            ``backports.lzma`` package to be additionally installed. Using
+            ``'zstd'`` requires Python 3.14.
 
             Example:
 
@@ -3858,16 +3884,19 @@ class CNF(Formula, object):
 
         dest |= set(range(1, self.nv + 1))
 
-    def _iter(self, outermost=False):
+    def _iter(self, seen, outermost=False):
         """
             This is a copy of :meth:`__iter__`, to be consistent with
             :class:`Formula`.
         """
 
-        if outermost:
-            yield from self.clauses
-        else:
-            yield from self.encoded
+        if not self in seen:
+            seen[self] = True
+
+            if outermost:
+                yield from self.clauses
+            else:
+                yield from self.encoded
 
     def simplified(self, assumptions=[]):
         """
@@ -3933,7 +3962,7 @@ class WCNF(object):
             Read a WCNF formula from a file in the DIMACS format. A file name
             is expected as an argument. A default argument is ``comment_lead``
             for parsing comment lines. A given file can be compressed by either
-            gzip, bzip2, or lzma.
+            gzip, bzip2, lzma, or zstd.
 
             :param fname: name of a file to parse.
             :param comment_lead: a list of characters leading comment lines
@@ -3944,11 +3973,12 @@ class WCNF(object):
             :type compressed_with: str
 
             Note that the ``compressed_with`` parameter can be ``None`` (i.e.
-            the file is uncompressed), ``'gzip'``, ``'bzip2'``, ``'lzma'``, or
-            ``'use_ext'``. The latter value indicates that compression type
-            should be automatically determined based on the file extension.
-            Using ``'lzma'`` in Python 2 requires the ``backports.lzma``
-            package to be additionally installed.
+            the file is uncompressed), ``'gzip'``, ``'bzip2'``, ``'lzma'``,
+            ``'zstd'``, or ``'use_ext'``. The latter value indicates that
+            compression type should be automatically determined based on the
+            file extension. Using ``'lzma'`` in Python 2 requires the
+            ``backports.lzma`` package to be additionally installed. Using
+            ``'zstd'`` requires Python 3.14.
 
             Usage example:
 
@@ -4149,7 +4179,7 @@ class WCNF(object):
             CNF format. A file name is expected as an argument. Additionally,
             supplementary comment lines can be specified in the ``comments``
             parameter. Also, a file can be compressed using either gzip, bzip2,
-            or lzma (xz).
+            lzma (xz), or zstd.
 
             :param fname: a file name where to store the formula.
             :param comments: additional comments to put in the file.
@@ -4159,12 +4189,13 @@ class WCNF(object):
             :type comments: list(str)
             :type compress_with: str
 
-            Note that the ``compress_with`` parameter can be ``None`` (i.e.
-            the file is uncompressed), ``'gzip'``, ``'bzip2'``, ``'lzma'``, or
-            ``'use_ext'``. The latter value indicates that compression type
-            should be automatically determined based on the file extension.
-            Using ``'lzma'`` in Python 2 requires the ``backports.lzma``
-            package to be additionally installed.
+            Note that the ``compressed_with`` parameter can be ``None`` (i.e.
+            the file is uncompressed), ``'gzip'``, ``'bzip2'``, ``'lzma'``,
+            ``'zstd'``, or ``'use_ext'``. The latter value indicates that
+            compression type should be automatically determined based on the
+            file extension. Using ``'lzma'`` in Python 2 requires the
+            ``backports.lzma`` package to be additionally installed. Using
+            ``'zstd'`` requires Python 3.14.
 
             Example:
 

{python_sat-1.8.dev19 → python_sat-1.8.dev20/python_sat.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-sat
-Version: 1.8.dev19
+Version: 1.8.dev20
 Summary: A Python library for prototyping with SAT oracles
 Home-page: https://github.com/pysathq/pysat
 Author: Alexey Ignatiev, Joao Marques-Silva, Antonio Morgado