str8ts_solver 0.1.0__tar.gz

str8ts_solver-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Piotr Idzik
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

str8ts_solver-0.1.0/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: str8ts_solver
+Version: 0.1.0
+Summary: str8ts solver using z3
+Author: Piotr Idzik
+Author-email: vil02_str8ts_solver@10g.pl
+Project-URL: repository, https://github.com/vil02/str8ts_solver
+Keywords: str8ts,str8ts solver,z3
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: z3-solver==4.15.4.0
+Provides-Extra: dev
+Requires-Dist: black==25.12.0; extra == "dev"
+Requires-Dist: coverage==7.13.0; extra == "dev"
+Requires-Dist: flake8-bugbear==25.11.29; extra == "dev"
+Requires-Dist: flake8-pytest-style==2.2.0; extra == "dev"
+Requires-Dist: flake8==7.3.0; extra == "dev"
+Requires-Dist: isort==7.0.0; extra == "dev"
+Requires-Dist: mypy==1.19.1; extra == "dev"
+Requires-Dist: pylint==4.0.4; extra == "dev"
+Requires-Dist: pyright[nodejs]==1.1.407; extra == "dev"
+Requires-Dist: pytest==9.0.2; extra == "dev"
+Requires-Dist: ruff==0.14.9; extra == "dev"
+Requires-Dist: xenon==0.9.3; extra == "dev"
+Dynamic: license-file
+
+# str8ts_solver/
+
+[Str8ts](https://en.wikipedia.org/wiki/Str8ts) solver using [z3](https://github.com/Z3Prover/z3).

str8ts_solver-0.1.0/README.md

@@ -0,0 +1,3 @@
+# str8ts_solver/
+
+[Str8ts](https://en.wikipedia.org/wiki/Str8ts) solver using [z3](https://github.com/Z3Prover/z3).

str8ts_solver-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[project]
+name = "str8ts_solver"
+version = "0.1.0"
+description = "str8ts solver using z3"
+authors = [
+  {email = "vil02_str8ts_solver@10g.pl"},
+  {name = "Piotr Idzik"}
+]
+readme = "README.md"
+requires-python = ">=3.12"
+keywords = ["str8ts", "str8ts solver", "z3"]
+
+dependencies = [
+    "z3-solver==4.15.4.0"
+]
+
+[project.optional-dependencies]
+dev = [
+    "black==25.12.0",
+    "coverage==7.13.0",
+    "flake8-bugbear==25.11.29",
+    "flake8-pytest-style==2.2.0",
+    "flake8==7.3.0",
+    "isort==7.0.0",
+    "mypy==1.19.1",
+    "pylint==4.0.4",
+    "pyright[nodejs]==1.1.407",
+    "pytest==9.0.2",
+    "ruff==0.14.9",
+    "xenon==0.9.3"
+]
+
+[project.urls]
+repository = "https://github.com/vil02/str8ts_solver"

str8ts_solver-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

str8ts_solver-0.1.0/str8ts_solver/output_utils.py

@@ -0,0 +1,82 @@
+def _bottom_row_to_string(
+    in_row_num: int, row_size: int, blocked: set[tuple[int, int]]
+) -> str:
+    res = []
+    for x_pos in range(row_size):
+        if (x_pos, in_row_num) in blocked:
+            res.append("###")
+        else:
+            res.append("   ")
+    return "|" + "|".join(res) + "|"
+
+
+def _top_row_to_string(
+    in_row_num: int,
+    row_size: int,
+    blocked: set[tuple[int, int]],
+    known: dict[tuple[int, int], int],
+) -> str:
+    res = []
+    for x_pos in range(row_size):
+        cur_pos = (x_pos, in_row_num)
+        if cur_pos in blocked:
+            res.append("###")
+        elif cur_pos in known:
+            res.append("  !")
+        else:
+            res.append("   ")
+    return "|" + "|".join(res) + "|"
+
+
+def _mid_row_to_string(
+    in_row_num: int,
+    row_size: int,
+    blocked: set[tuple[int, int]],
+    known: dict[tuple[int, int], int],
+    solved: dict[tuple[int, int], int],
+) -> str:
+    res = []
+    for x_pos in range(row_size):
+        cur_pos = (x_pos, in_row_num)
+        if cur_pos in blocked:
+            if cur_pos in known:
+                res.append(f"#{known[cur_pos]}#")
+            else:
+                res.append("###")
+        else:
+            if cur_pos in known:
+                res.append(f" {known[cur_pos]} ")
+            else:
+                res.append(f" {solved.get(cur_pos, ' ')} ")
+    return "|" + "|".join(res) + "|"
+
+
+def _row_to_string(
+    in_row_num: int,
+    row_size: int,
+    blocked: set[tuple[int, int]],
+    known: dict[tuple[int, int], int],
+    solved: dict[tuple[int, int], int],
+) -> str:
+    top_row = _top_row_to_string(in_row_num, row_size, blocked, known)
+    mid_row = _mid_row_to_string(in_row_num, row_size, blocked, known, solved)
+    bottom_row = _bottom_row_to_string(in_row_num, row_size, blocked)
+    return "\n".join((top_row, mid_row, bottom_row))
+
+
+def _row_separator(in_row_size: int) -> str:
+    return str("+---" * in_row_size) + "+"
+
+
+def to_string(
+    size: tuple[int, int],
+    blocked: set[tuple[int, int]],
+    known: dict[tuple[int, int], int],
+    solved: dict[tuple[int, int], int],
+) -> str:
+    row_separator = _row_separator(size[0])
+    res = [row_separator]
+    for y_pos in range(size[1]):
+        res.append(_row_to_string(y_pos, size[0], blocked, known, solved))
+        res.append(row_separator)
+    return "\n".join(res)

str8ts_solver-0.1.0/str8ts_solver/solver.py

@@ -0,0 +1,176 @@
+import itertools
+
+import z3  # type: ignore
+
+
+def _shift(pos: tuple[int, int], shift: tuple[int, int]) -> tuple[int, int]:
+    res = tuple(sum(_) for _ in zip(pos, shift, strict=True))
+    assert len(res) == 2
+    return res
+
+
+def _extract_block(
+    unknowns, pos: tuple[int, int], direction: tuple[int, int]
+) -> list[tuple[int, int]]:
+    assert pos in unknowns
+    res = [pos]
+    cur_pos = _shift(pos, direction)
+    while cur_pos in unknowns:
+        res.append(cur_pos)
+        cur_pos = _shift(cur_pos, direction)
+    return res
+
+
+def _gen_horizontal_blocks(size: tuple[int, int], unknowns):
+    for y_pos in range(size[1]):
+        x_pos = 0
+        while x_pos < size[0]:
+            if (x_pos, y_pos) in unknowns:
+                cur_block = _extract_block(unknowns, (x_pos, y_pos), (1, 0))
+                if len(cur_block) > 1:
+                    yield cur_block
+                x_pos += len(cur_block)
+            else:
+                x_pos += 1
+
+
+def _gen_vertical_blocks(size: tuple[int, int], unknowns):
+    for x_pos in range(size[0]):
+        y_pos = 0
+        while y_pos < size[1]:
+            if (x_pos, y_pos) in unknowns:
+                cur_block = _extract_block(unknowns, (x_pos, y_pos), (0, 1))
+                if len(cur_block) > 1:
+                    yield cur_block
+                y_pos += len(cur_block)
+            else:
+                y_pos += 1
+
+
+def _define_unknowns(size: tuple[int, int], blocked: set[tuple[int, int]]):
+    return {
+        (x_pos, y_pos): z3.Int(f"u_{x_pos}_{y_pos}")
+        for x_pos, y_pos in itertools.product(range(size[0]), range(size[1]))
+        if (x_pos, y_pos) not in blocked
+    }
+
+
+def _add_basic_constrains(solver, unknowns, known, value_limit) -> None:
+    for pos, unknown in unknowns.items():
+        if pos in known:
+            solver.add(unknown == known[pos])
+        else:
+            solver.add(0 < unknown)
+            solver.add(unknown <= value_limit)
+
+
+def _add_different_than_if_exists(
+    solver, unknowns, unknown_id: tuple[int, int], value: int
+) -> None:
+    if unknown_id in unknowns:
+        solver.add(unknowns[unknown_id] != value)
+
+
+def _add_constrains_from_blocked(
+    solver,
+    unknowns,
+    size: tuple[int, int],
+    blocked: set[tuple[int, int]],
+    known: dict[tuple[int, int], int],
+) -> None:
+    for cur_blocked in blocked:
+        if cur_blocked in known:
+            cur_blocked_x, cur_blocked_y = cur_blocked
+            for x_pos in range(size[0]):
+                _add_different_than_if_exists(
+                    solver, unknowns, (x_pos, cur_blocked_y), known[cur_blocked]
+                )
+            for y_pos in range(size[1]):
+                _add_different_than_if_exists(
+                    solver, unknowns, (cur_blocked_x, y_pos), known[cur_blocked]
+                )
+
+
+def _add_block_constrain(
+    solver, unknowns, block: list[tuple[int, int]], block_id: str
+) -> None:
+    cur_limit = z3.Int(block_id)
+    solver.add(cur_limit > 0)
+    for _ in block:
+        solver.add(cur_limit <= unknowns[_])
+        solver.add(unknowns[_] < cur_limit + len(block))
+    solver.add(z3.Distinct(*(unknowns[_] for _ in block)))
+
+
+def _add_all_block_constrains(solver, unknowns, size: tuple[int, int]) -> None:
+    for block_num, cur_block in enumerate(_gen_horizontal_blocks(size, unknowns)):
+        _add_block_constrain(solver, unknowns, cur_block, f"h_{block_num}")
+
+    for block_num, cur_block in enumerate(_gen_vertical_blocks(size, unknowns)):
+        _add_block_constrain(solver, unknowns, cur_block, f"v_{block_num}")
+
+
+def _add_entries_in_all_rows_are_unique_constrains(
+    solver, unknowns, size: tuple[int, int]
+):
+    for y_pos in range(size[1]):
+        cur_row = [
+            unknowns[(x_pos, y_pos)]
+            for x_pos in range(size[0])
+            if (x_pos, y_pos) in unknowns
+        ]
+        solver.add(z3.Distinct(*cur_row))
+
+
+def _add_entries_in_all_cols_are_unique_constrains(
+    solver, unknowns, size: tuple[int, int]
+):
+    for x_pos in range(size[0]):
+        cur_col = [
+            unknowns[(x_pos, y_pos)]
+            for y_pos in range(size[1])
+            if (x_pos, y_pos) in unknowns
+        ]
+        solver.add(z3.Distinct(*cur_col))
+
+
+def _create_solver(
+    size: tuple[int, int],
+    blocked: set[tuple[int, int]],
+    known: dict[tuple[int, int], int],
+):
+    solver = z3.Solver()
+    unknowns = _define_unknowns(size, blocked)
+    _add_basic_constrains(solver, unknowns, known, max(size))
+    _add_constrains_from_blocked(solver, unknowns, size, blocked, known)
+    _add_all_block_constrains(solver, unknowns, size)
+    _add_entries_in_all_cols_are_unique_constrains(solver, unknowns, size)
+    _add_entries_in_all_rows_are_unique_constrains(solver, unknowns, size)
+
+    return unknowns, solver
+
+
+def _read_solution(unknowns, solver) -> dict[tuple[int, int], int]:
+    assert solver.check() == z3.sat
+    model = solver.model()
+    return {_: model[unknowns[_]].as_long() for _ in unknowns}
+
+
+def solve(
+    size: tuple[int, int],
+    blocked: set[tuple[int, int]],
+    known: dict[tuple[int, int], int],
+) -> dict[tuple[int, int], int] | None:
+    unknowns, solver = _create_solver(size, blocked, known)
+    if solver.check() != z3.sat:
+        return None
+    solved = _read_solution(unknowns, solver)
+    assert all(solved[_] == known[_] for _ in solved if _ in known)
+    for cur_block in itertools.chain(
+        _gen_horizontal_blocks(size, unknowns), _gen_vertical_blocks(size, unknowns)
+    ):
+        solved_values = {solved[_] for _ in cur_block}
+        assert len(solved_values) == len(cur_block)
+        assert solved_values == set(range(min(solved_values), max(solved_values) + 1))
+
+    return solved

str8ts_solver-0.1.0/str8ts_solver.egg-info/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: str8ts_solver
+Version: 0.1.0
+Summary: str8ts solver using z3
+Author: Piotr Idzik
+Author-email: vil02_str8ts_solver@10g.pl
+Project-URL: repository, https://github.com/vil02/str8ts_solver
+Keywords: str8ts,str8ts solver,z3
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: z3-solver==4.15.4.0
+Provides-Extra: dev
+Requires-Dist: black==25.12.0; extra == "dev"
+Requires-Dist: coverage==7.13.0; extra == "dev"
+Requires-Dist: flake8-bugbear==25.11.29; extra == "dev"
+Requires-Dist: flake8-pytest-style==2.2.0; extra == "dev"
+Requires-Dist: flake8==7.3.0; extra == "dev"
+Requires-Dist: isort==7.0.0; extra == "dev"
+Requires-Dist: mypy==1.19.1; extra == "dev"
+Requires-Dist: pylint==4.0.4; extra == "dev"
+Requires-Dist: pyright[nodejs]==1.1.407; extra == "dev"
+Requires-Dist: pytest==9.0.2; extra == "dev"
+Requires-Dist: ruff==0.14.9; extra == "dev"
+Requires-Dist: xenon==0.9.3; extra == "dev"
+Dynamic: license-file
+
+# str8ts_solver/
+
+[Str8ts](https://en.wikipedia.org/wiki/Str8ts) solver using [z3](https://github.com/Z3Prover/z3).

str8ts_solver-0.1.0/str8ts_solver.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+str8ts_solver/__init__.py
+str8ts_solver/output_utils.py
+str8ts_solver/solver.py
+str8ts_solver.egg-info/PKG-INFO
+str8ts_solver.egg-info/SOURCES.txt
+str8ts_solver.egg-info/dependency_links.txt
+str8ts_solver.egg-info/requires.txt
+str8ts_solver.egg-info/top_level.txt
+tests/test_solve.py
+tests/test_to_string.py

str8ts_solver-0.1.0/str8ts_solver.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

str8ts_solver-0.1.0/str8ts_solver.egg-info/requires.txt

@@ -0,0 +1,15 @@
+z3-solver==4.15.4.0
+
+[dev]
+black==25.12.0
+coverage==7.13.0
+flake8-bugbear==25.11.29
+flake8-pytest-style==2.2.0
+flake8==7.3.0
+isort==7.0.0
+mypy==1.19.1
+pylint==4.0.4
+pyright[nodejs]==1.1.407
+pytest==9.0.2
+ruff==0.14.9
+xenon==0.9.3

str8ts_solver-0.1.0/str8ts_solver.egg-info/top_level.txt

@@ -0,0 +1 @@
+str8ts_solver

str8ts_solver-0.1.0/tests/test_solve.py

@@ -0,0 +1,33 @@
+import pytest
+
+from str8ts_solver.solver import solve
+
+from . import samples
+
+
+def _extract_test_case(
+    sample: samples.Sample,
+) -> tuple[
+    tuple[int, int],
+    set[tuple[int, int]],
+    dict[tuple[int, int], int],
+    dict[tuple[int, int], int],
+]:
+    return sample.size, sample.blocked, sample.known, sample.solved
+
+
+@pytest.mark.parametrize(
+    ("size", "blocked", "known", "expected"),
+    [
+        _extract_test_case(samples.SAMPLE_1),
+        _extract_test_case(samples.SAMPLE_2),
+        _extract_test_case(samples.SAMPLE_3),
+    ],
+)
+def test_solve(
+    size: tuple[int, int],
+    blocked: set[tuple[int, int]],
+    known: dict[tuple[int, int], int],
+    expected: dict[tuple[int, int], int],
+) -> None:
+    assert solve(size, blocked, known) == expected

str8ts_solver-0.1.0/tests/test_to_string.py

@@ -0,0 +1,63 @@
+import pytest
+
+from str8ts_solver.output_utils import to_string
+
+from . import samples
+
+
+def _extract_test_case_blank(
+    sample: samples.Sample,
+) -> tuple[
+    tuple[int, int],
+    set[tuple[int, int]],
+    dict[tuple[int, int], int],
+    str,
+]:
+    return sample.size, sample.blocked, sample.known, sample.blank_str
+
+
+@pytest.mark.parametrize(
+    ("size", "blocked", "known", "expected"),
+    [
+        _extract_test_case_blank(samples.SAMPLE_1),
+        _extract_test_case_blank(samples.SAMPLE_2),
+        _extract_test_case_blank(samples.SAMPLE_3),
+    ],
+)
+def test_to_string_with_blank(
+    size: tuple[int, int],
+    blocked: set[tuple[int, int]],
+    known: dict[tuple[int, int], int],
+    expected: str,
+) -> None:
+    assert to_string(size, blocked, known, {}) == expected
+
+
+def _extract_test_case_solved(
+    sample: samples.Sample,
+) -> tuple[
+    tuple[int, int],
+    set[tuple[int, int]],
+    dict[tuple[int, int], int],
+    dict[tuple[int, int], int],
+    str,
+]:
+    return sample.size, sample.blocked, sample.known, sample.solved, sample.solved_str
+
+
+@pytest.mark.parametrize(
+    ("size", "blocked", "known", "solved", "expected"),
+    [
+        _extract_test_case_solved(samples.SAMPLE_1),
+        _extract_test_case_solved(samples.SAMPLE_2),
+        _extract_test_case_solved(samples.SAMPLE_3),
+    ],
+)
+def test_to_string_with_solved(
+    size: tuple[int, int],
+    blocked: set[tuple[int, int]],
+    known: dict[tuple[int, int], int],
+    solved: dict[tuple[int, int], int],
+    expected: str,
+) -> None:
+    assert to_string(size, blocked, known, solved) == expected