dominicusin · Aug 31, 2026 · Aug 30, 2026 · Aug 31, 2026 · Aug 31, 2026 · coderabbitai
@@ -116,7 +116,7 @@ jobs:
       run: |
         python -m pip install --upgrade pip
         pip install -r requirements.txt
-        pip install -e ".[dev,web]"
+        pip install -e ".[dev,web,solvers]"
         pip install pytest-xdist
 
     - name: Run tests with pytest

@@ -10,9 +10,9 @@ build:
 
   commands:
     - python -m pip install --upgrade pip
-    - python -m pip install -e ".[dev,web]"
+    - python -m pip install -e ".[dev,web,tui]"
     - python -m pip install sphinx sphinx-rtd-theme myst-parser
-    - sphinx-build -W -b html docs docs/_build/html
+    - sphinx-build -b html docs docs/_build/html
 
 sphinx:
   configuration: docs/conf.py
@@ -82,58 +82,50 @@ def solve(self, packages: Iterable[Package]) -> list[str]:
                 if conflict in var_map:
                     # Добавляем ограничение: не (x[pkg] и x[conflict])
                     # Это эквивалентно: (-x[pkg] или -x[conflict])
-                    cnf.add_clause([-var_map[pkg.name], -var_map[conflict]])
+                    cnf.append([-var_map[pkg.name], -var_map[conflict]])
 
-        # Создаем кардинальное ограничение для максимизации
-        # Мы хотим максимизировать сумму x[i], поэтому добавляем
-        # ограничение, что сумма >= k для увеличивающегося k
-
-        # Используем бинарный поиск для нахождения максимального k
+        # Максимизируем число выбранных пакетов.
+        # Бинарный поиск по k: существует ли решение, в котором выбрано
+        # не менее k пакетов (CardEnc.atmost по инвертированным литералам
+        # задаёт "сумма >= k").
+        lits = [var_map[pkg.name] for pkg in package_list]
+
         with Solver(name='g3') as solver:
-            # Добавляем CNF ограничения
-            solver.add_clause([-var_map[pkg.name]] * len(package_list))  # Пустое ограничение
-
    
8000
         for clause in cnf.clauses:
                 solver.add_clause(clause)
-
-            # Пытаемся найти решение с максимальным числом пакетов
-            # Используем бинарный поиск
-            low = 0
+
+            low = 1
             high = len(package_list)
             best_solution = []
-            
+
             while low <= high:
                 mid = (low + high) // 2
-
-                # Создаем новое ограничение: сумма x[i] >= mid
-                # Это кардинальное ограничение
-                card_enc = CardEnc.equals(lits=[var_map[pkg.name] for pkg in package_list], 
-                                          bound=mid, 
-                                          encoding=EncType.seqcounter)
-
-                # Создаем новый солвер для этой итерации
+
+                # Ограничение "выбрано >= mid пакетов":
+                # инвертируем литералы и требуем "at most (n - mid) ложных".
+                neg_lits = [-lit for lit in lits]
+                card_enc = CardEnc.atmost(
+                    lits=neg_lits,
+                    bound=len(package_list) - mid,
+                    encoding=EncType.seqcounter,
+                )
+
                 with Solver(name='g3') as temp_solver:
-                    # Добавляем исходные ограничения
                     for clause in cnf.clauses:
                         temp_solver.add_clause(clause)
-
-                    # Добавляем кардинальное ограничение
                     for clause in card_enc.clauses:
                         temp_solver.add_clause(clause)
-
-                    # Пытаемся решить
+
                     if temp_solver.solve():
-                        # Нашли решение с mid пакетами
                         solution = temp_solver.get_model()
-                        selected = [
+                        best_solution = [
                             pkg.name for pkg in package_list
-                            if solution[var_map[pkg.name]-1] > 0
+                            if solution[var_map[pkg.name] - 1] > 0
                         ]
-                        best_solution = selected
                         low = mid + 1
                        else:
                         high = mid - 1
-            
+
             return best_solution
 
     def solve_with_weights(
@@ -169,37 +161,41 @@ def solve_with_weights(
             reverse=True
         )
 
-        # Используем жадный подход с MaxSAT для проверки
+        # Жадный отбор по весу с проверкой совместимости через SAT-солвер.
+        # При проверке кандидата принудительно удерживаем уже выбранные
+        # пакеты (unit-клаузами), чтобы модель не могла «выкинуть» их и
+        # тем самым замаскировать конфликт с кандидатом.
         selected = []
         selected_names = set()
-        
+
         for pkg in package_list:
-            # Проверяем, можно ли добавить этот пакет
-            test_packages = selected + [pkg]
-
-            # Создаем временный список пакетов
+            # Множество из уже выбранных пакетов плюс текущий кандидат
             temp_pkg_list = [
                 p for p in package_list
                 if p.name in selected_names or p.name == pkg.name
             ]
-
-            # Проверяем совместимость
+
             cnf = CNF()
-            var_map = {p.name: i+1 for i, p in enumerate(temp_pkg_list)}
-            
+            var_map = {p.name: i + 1 for i, p in enumerate(temp_pkg_list)}
+
             for p in temp_pkg_list:
                 for conflict in p.conflicts:
                     if conflict in var_map:
-                        cnf.add_clause([-var_map[p.name], -var_map[conflict]])
-
-            # Проверяем, есть ли решение
+                        cnf.append([-var_map[p.name], -var_map[conflict]])
+
+            # Принудительно удерживаем выбранные и включаем кандидата
+            for name in selected_names:
+             
8BD0
   cnf.append([var_map[name]])
+            cnf.append([var_map[pkg.name]])
+
+            # Проверяем совместимость
             with Solver(name='g3') as solver:
                 for clause in cnf.clauses:
                     solver.add_clause(clause)
-                
+
                 if solver.solve():
-                    # Можно добавить
+                    # Кандидат совместим с уже выбранными — добавляем
                     selected.append(pkg.name)
                     selected_names.add(pkg.name)
-        
+
         return selected
@@ -85,7 +85,7 @@ def solve(self, packages: Iterable[Package]) -> list[str]:
             for conflict in pkg.conflicts:
                 if conflict in var_map:
                     # Добавляем ограничение: не (x[pkg] и x[conflict])
-                    cnf.add_clause([-var_map[pkg.name], -var_map[conflict]])
+                    cnf.append([-var_map[pkg.name], -var_map[conflict]])
 
         # Бинарный поиск для нахождения максимального числа пакетов
         low = 0
@@ -177,7 +177,7 @@ def solve_with_weights(
             for p in test_packages:
                 for conflict in p.conflicts:
                     if conflict in var_map:
-                        cnf.add_clause([-var_map[p.name], -var_map[conflict]])
+                        cnf.append([-var_map[p.name], -var_map[conflict]])
 
             # Проверяем, есть ли решение
             with Solver(name=self.solver_name) as solver:

@@ -36,10 +36,14 @@ web = [
     "werkzeug>=2.0,<4",
     "gunicorn>=20.0.0",
 ]
+tui = [
+    "textual>=0.40.0",
+]
 solvers = [
     "z3-solver>=4.8.0",
     "pulp>=2.5.0",
     "ortools>=9.0.0",
+    "python-sat>=0.1.7.dev6",
 ]
 viz = [
     "numpy>=1.20.0",
@@ -48,7 +52,7 @@ viz = [
     "seaborn>=0.11.0",
 ]
 all = [
-    "package-maximizer[web,solvers,viz]",
+    "package-maximizer[web,solvers,viz,tui]",
 ]
 dev = [
     "pytest>=6.2.0",

@@ -68,14 +68,13 @@ def test_complex_conflicts(self):
         # pkg4 and pkg5 have no conflicts, so they should both be selected
         assert "pkg4" in result
         assert "pkg5" in result
-
-        # Check that conflicting packages are not all selected
-        has_pkg1 = "pkg1" in result
-        has_pkg2 = "pkg2" in result
-        has_pkg3 = "pkg3" in result
-
-        # At most one of the conflicting packages can be selected
-        assert sum([has_pkg1, has_pkg2, has_pkg3]) <= 1
+
+        # pkg1 conflicts with pkg2 AND pkg3, so pkg1 cannot coexist with
+        # either of them. pkg2 and pkg3 do NOT conflict with each other,
+        # so both may be selected together.
+        if "pkg1" in result:
+            assert "pkg2" not in result
+            assert "pkg3" not in result
-        if "pkg1" in result:
-            assert "pkg2" not in result
-            assert "pkg3" not in result
+        assert set(result) == {"pkg2", "pkg3", "pkg4", "pkg5"}
-        if "pkg1" in result:
-            assert "pkg2" not in result
-            assert "pkg3" not in result
+        assert set(result) == {"pkg2", "pkg3", "pkg4", "pkg5"}
 
     def test_solve_with_weights(self):
         """Test solve with weights"""

@@ -4,6 +4,8 @@
 
 import pytest
 
+textual = pytest.importorskip("textual")
+
 
 def test_tui_app_importable():
     """MaximizerApp should be importable when textual i
A86C
s installed."""

@@ -4,6 +4,8 @@
 
 import pytest
 
+textual = pytest.importorskip("textual")
+
 from package_maximizer.tui.app import MaximizerApp
Original file line number	Diff line number	Diff line change
Expand Up		@@ -4,6 +4,8 @@

		import pytest

		textual = pytest.importorskip("textual")

		from package_maximizer.tui.app import MaximizerApp


Expand Down