base-loom-server 1.2b2__tar.gz → 1.2b4__tar.gz

{base_loom_server-1.2b2/src/base_loom_server.egg-info → base_loom_server-1.2b4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: base_loom_server
-Version: 1.2b2
+Version: 1.2b4
 Summary: Base package for web servers that control dobby multi-shaft looms
 Author-email: Russell Owen <r3owen@gmail.com>
 Project-URL: Homepage, https://pypi.org/project/base-loom-server/

{base_loom_server-1.2b2 → base_loom_server-1.2b4}/docs/version_history.md

@@ -1,5 +1,13 @@
 # Version History
 
+## 1.2b4 2026-03-07
+
+* Further improve computation of tabby.
+
+## 1.2b3 2026-03-06
+
+* Improve computation of tabby.
+
 ## 1.2b2 2026-03-05
 
 * Fix initial display of tabby panel.

{base_loom_server-1.2b2 → base_loom_server-1.2b4}/docs/weaving_tabby.md

@@ -7,7 +7,7 @@
 </div>
 
 The **Tabby** mode allows you to weave tabby (plain weave), or a close approximation.
-This can be used to weaving hems or item separators.
+This can be used to weave hems or item separators.
 
 Caveats:
 

base_loom_server-1.2b4/src/base_loom_server/compute_tabby.py

@@ -0,0 +1,249 @@
+import functools
+import itertools
+import operator
+
+from .utils import prune_duplicates
+
+# Maximum number of starting points for iterations in compute_tabby_shaft_word1.
+# Avoid very large values to keep compute time reasonable.
+MAX_ITER_TABBY1 = 5
+
+
+def compute_num_transitions(tabby_shaft_word: int, threading: list[int]) -> int:
+    """Compute the number of transitions produced by a tabby shaft word.
+
+    The largest possible value is len(threading_shaft_words) - 1.
+
+    Args:
+        tabby_shaft_word: Tabby shaft word.
+        threading: Shaft index (0-based) for each warp end.
+            Negative values are ignored (and adjacent duplicate values
+            naturally do not affect the result).
+    """
+    threading_shaft_words = [1 << shaft for shaft in threading if shaft >= 0]
+    return _compute_num_transitions_impl(
+        tabby_shaft_word=tabby_shaft_word, threading_shaft_words=threading_shaft_words
+    )
+
+
+def _compute_num_transitions_impl(tabby_shaft_word: int, threading_shaft_words: list[int]) -> int:
+    """Implementation of compute_num_transitions.
+
+    Args:
+        tabby_shaft_word: Tabby shaft word.
+        threading_shaft_words: Shaft word for each warp end.
+    """
+    is_up_list = [bool(tsw & tabby_shaft_word) for tsw in threading_shaft_words]
+    return sum(1 for val1, val2 in itertools.pairwise(is_up_list) if val1 != val2)
+
+
+def compute_tabby_shaft_word1_simple(threading: list[int]) -> int:
+    """Trivial tabby computation that may fail.
+
+    Handle the trivial case that all even threads are on different
+    shafts than all odd threads. Return 0 if that is not the case.
+
+    Args:
+        threading: Shaft index (0-based) for each warp end.
+            Negative values and adjacent duplicates are ignored.
+
+    Returns:
+        Tabby shaft word, or 0 if the simple case is not satified.
+    """
+    # Ignore unthreaded shafts and duplicates
+    pruned_threading = prune_duplicates([shaft for shaft in threading if shaft >= 0])
+    num_threaded_shafts = len(set(threading))
+    if len(threading) <= 1:
+        raise ValueError("Need at least 2 threaded warp ends to weave tabby.")
+    if num_threaded_shafts <= 1:
+        raise ValueError("Need at least 2 threaded shafts to weave tabby.")
+
+    threading_shaft_words = [1 << shaft for shaft in pruned_threading]
+    return _compute_tabby_shaft_word1_simple_impl(threading_shaft_words=threading_shaft_words)
+
+
+def _compute_tabby_shaft_word1_simple_impl(threading_shaft_words: list[int]) -> int:
+    """Implementation of compute_tabby_shaft_word1_simple.
+
+    Handle the trivial case that all (threaded and non-duplicated)
+    even threads are on different shafts than all odd threads.
+    Return 0 if that is not the case.
+
+    Args:
+        threading_shaft_words: Shaft words for each warp end.
+            Duplicates should be removed.
+
+    Returns:
+        Tabby shaft word, or 0 if the simple case is not satified.
+    """
+    if len(threading_shaft_words) == 0:
+        return 0
+
+    tabby_shaft_word = 0
+    odd_ends_shaft_word = functools.reduce(operator.or_, threading_shaft_words[0::2], 0)
+    even_ends_shaft_word = functools.reduce(operator.or_, threading_shaft_words[1::2], 0)
+
+    if even_ends_shaft_word & odd_ends_shaft_word == 0:
+        min_shaft_word = min(threading_shaft_words)
+        tabby_shaft_word = (
+            even_ends_shaft_word if min_shaft_word & even_ends_shaft_word > 0 else odd_ends_shaft_word
+        )
+
+    return tabby_shaft_word
+
+
+def compute_tabby_shaft_word1(threading: list[int]) -> int:
+    """Compute which shaft_set should go up for the best tabby pick 1.
+
+    Args:
+        threading: Shaft index (0-based) for each warp end.
+            Negative values and adjacent duplicates are ignored.
+
+    Returns:
+        shaft_word: Which shaft_set should be up for pick 1, 3, 5... of tabby.
+
+    Raises:
+        ValueError if there are fewer than 2 threaded warp ends,
+            or if the warp ends are threaded on fewer than 2 different shaft_set.
+
+    Notes:
+        The algorithm works by examining transitions between adjacent warp ends, as follows:
+
+        First make a pruned version of threading with no negative values
+        (warp ends that are not threaded) and no repeating ends.
+
+        Initialize tabby_shafts and seen_shafts to the first entry in the pruned threading.
+        For each shaft in the rest of the pruned threading:
+            If shaft is not in seen_shafts:
+                Add it to seen_shafts
+                If previous_shaft is not in tabby_shafts, put the new shaft in tabby_shafts.
+            Set previous_shaft to shaft
+        If the resulting tabby shaft word does not included the minimum threaded shaft,
+        invert it to provide more predictable results.
+
+        Try this several times, from different starting points in the threading,
+        and pick the tabby that gives the most consecutive transitions.
+    """
+    # Ignore unthreaded shafts and duplicates
+    pruned_threading = prune_duplicates([shaft for shaft in threading if shaft >= 0])
+    num_threaded_shafts = len(set(threading))
+    if len(threading) <= 1:
+        raise ValueError("Need at least 2 threaded warp ends to weave tabby.")
+    if num_threaded_shafts <= 1:
+        raise ValueError("Need at least 2 threaded shafts to weave tabby.")
+
+    threading_shaft_words = [1 << shaft for shaft in pruned_threading]
+
+    # First try the simple algorithm. It is a common case, fast to evaluate,
+    # and gives maximum interlacement if it works at all.
+    try_tabby_word = _compute_tabby_shaft_word1_simple_impl(threading_shaft_words=threading_shaft_words)
+    if try_tabby_word != 0:
+        return try_tabby_word
+
+    # Try the harder and less ideal algorithm.
+    min_shaft_word = min(threading_shaft_words)
+    max_threaded_shaft = max(pruned_threading)
+    all_shafts_word = (1 << (max_threaded_shaft + 1)) - 1
+
+    best_num_transitions = 0
+    best_tabby_shaft_word = 0
+
+    # Try starting at several different points in the threading,
+    # in order to get a somewhat better result.
+    num_threads = len(pruned_threading)
+    start_interval = ((num_threads - 1) // MAX_ITER_TABBY1) + 1
+    if num_threads < MAX_ITER_TABBY1 * 2:
+        # Not many threads; don't worry about limiting the number of iterations.
+        start_interval = 1
+    niter = 0
+    for start_index in range(0, num_threads, start_interval):
+        niter += 1
+        tabby_shaft_word = threading_shaft_words[start_index]
+        seen_shafts_word = threading_shaft_words[start_index]
+        num_seen_shafts = 1
+        for prev_shaft_word, shaft_word in itertools.pairwise(
+            itertools.chain(threading_shaft_words[start_index:], threading_shaft_words[:start_index])
+        ):
+            if shaft_word & seen_shafts_word > 0:
+                continue
+            seen_shafts_word |= shaft_word
+            num_seen_shafts += 1
+            if prev_shaft_word & tabby_shaft_word == 0:
+                # The previous thread's shaft word is not part of the tabby word
+                # so make this new thread's shaft part of the tabby word.
+                tabby_shaft_word |= shaft_word
+            if num_seen_shafts == num_threaded_shafts:
+                # We have seen all shafts; stop
+                break
+
+        # Pick the tabby word that includes the lowest numbered threaded shaft
+        if min_shaft_word & tabby_shaft_word == 0:
+            tabby_shaft_word = ~tabby_shaft_word & all_shafts_word
+
+        num_transitions = _compute_num_transitions_impl(
+            tabby_shaft_word=tabby_shaft_word,
+            threading_shaft_words=threading_shaft_words,
+        )
+        if num_transitions > best_num_transitions:
+            best_num_transitions = num_transitions
+            best_tabby_shaft_word = tabby_shaft_word
+            if num_transitions == len(pruned_threading) - 1:
+                break
+    return best_tabby_shaft_word
+
+
+def compute_tabby_shaft_word2(tabby_shaft_word1: int, threading: list[int]) -> int:
+    """Compute tabby_shaft_word2 as the complement of tabby_shaft_word1.
+
+    Args:
+        tabby_shaft_word1: tabby shaft word computed by compute_tabby_shaft_word1.
+        threading: Shaft index (0-based) for each warp end.
+            Negative values and adjacent duplicates are ignored.
+
+    Returns:
+        tabby_shaft_word2: which shaft_set should be up picks 2, 4, 6... of tabby.
+            The complement tabby_shaft_word1, will all shaft_set beyond max_threaded_shaft_number
+            set to 0.
+
+    Raises:
+        ValueError if max_threaded_shaft_number < 2.
+
+    Notes:
+        Takes threading instead of max_threaded_shaft_number for two reasons:
+
+        * It proved too easy to mis-compute the value. Threading is 0-based
+            and it was too easy to pass in max(threading), which is 1 too small.
+        * We may wish to switch to using a sparse mask of threaded shafts,
+            lowering all unused shafts, not just those beyond the last threaded shaft.
+    """
+    if tabby_shaft_word1 < 1:
+        raise ValueError(f"{tabby_shaft_word1=} must be positive")
+    max_threaded_shaft_number = max(threading) + 1  # threading is 0-based
+    if max_threaded_shaft_number <= 1:
+        raise ValueError(f"{max_threaded_shaft_number=} must be > 1")
+
+    all_shafts_mask = (1 << max_threaded_shaft_number) - 1
+    tabby_shaft_word2 = ~tabby_shaft_word1 & all_shafts_mask
+    if tabby_shaft_word2 < 1:
+        raise ValueError(f"Result is invalid; check {tabby_shaft_word1=} and {threading=}")
+    return tabby_shaft_word2
+
+
+def compute_tabby_shaft_words(threading: list[int]) -> tuple[int, int]:
+    """Compute tabby_shaft_words 1 and 2.
+
+    Args:
+        threading: Shaft index (0-based) for each warp end.
+            Negative values and adjacent duplicates are ignored.
+
+    Returns:
+        (shaft_word1, shaft_word2): Which shaft_set should be up for the two picks of tabby
+            (word 1 is for picks 1, 3, 5.., word 2 is for picks 2, 4, 6...).
+
+    Raises:
+        ValueError if there are fewer than 2 threaded warp ends,
+            or if the warp ends are threaded on fewer than 2 different shaft_set.
+    """
+    tabby_shaft_word1 = compute_tabby_shaft_word1(threading=threading)
+    tabby_shaft_word2 = compute_tabby_shaft_word2(tabby_shaft_word1=tabby_shaft_word1, threading=threading)
+    return (tabby_shaft_word1, tabby_shaft_word2)

{base_loom_server-1.2b2 → base_loom_server-1.2b4}/src/base_loom_server/reduced_pattern.py

@@ -38,7 +38,7 @@ class Pick:
 
     Args:
         color: Weft color, as an index into the color table.
-        shaft_word: A bit mask, with bit 1 = shaft 0.
+        shaft_word: A bit mask, with bit 1 = shaft number 1 (index 0).
             The shaft is up if the bit is set.
     """
 
@@ -62,16 +62,27 @@ class ReducedPattern:
     Contains just enough information to allow loom control,
     with a simple display.
 
-    Picks are accessed by pick number, which is 1-based.
-    0 indicates that nothing has been woven.
-    Similarly for tabby picks and warp ends.
+    Warp ends that are not threaded on any shaft are omitted.
+    Warp ends that are threaded on more than one shaft are
+    only threaded on the lowest-numbered shaft.
+    Weft picks that are not treadled are omitted.
 
-    Shaft numbers in threading are 0-based.
+    Values in threading and warp_colors, are 0-based indices:
+
+    * threading is a list of shaft indices (shaft index 0 is shaft number 1).
+    * warp_colors is a list of indices into color_table.
+        Likewise for the color attribute of Pick.
+
+    pick_number and end_number0/1 are 1-based (in general "number"
+    in the name indicates it is 1-based).
+    A value of 0 indicates "no such pick" or "no such end",
+    and is the initial state of weaving and threading,
+    as well as a separator gap between pattern repeats.
 
     pick_number and end_number0/1 are within one pattern repeat,
     and repeats are tracked with related attributes.
-    tabby_pick_number is different, since repeats of tabby are not tracked
-    (as uninteresting), the value is a "total" pick number.
+    However, tabby_pick_number is absolute, because repeats of tabby
+    are not interesting, and so are not tracked.
     """
 
     type: str = dataclasses.field(init=False, default="ReducedPattern")
@@ -473,8 +484,9 @@ def reduced_pattern_from_pattern_data(name: str, data: dtx_to_wif.PatternData) -
 
     num_ends = max(data.threading.keys())
     end_numbers = list(range(1, num_ends + 1))
+    # Shaft numbers in threading are 0-based
     threading = [_smallest_shaft(data.threading.get(end_number, {0})) - 1 for end_number in end_numbers]
-    max_threaded_shaft = max(threading)
+    max_threaded_shaft_number = max(threading) + 1  # +1 because 1-based
 
     num_picks = max(data.liftplan.keys()) if data.liftplan else max(data.treadling.keys())
     pick_numbers = list(range(1, num_picks + 1))
@@ -493,10 +505,10 @@ def reduced_pattern_from_pattern_data(name: str, data: dtx_to_wif.PatternData) -
     if len(shaft_sets) != len(weft_colors):
         raise RuntimeError(f"{len(shaft_sets)=} != {len(weft_colors)=}\n{shaft_sets=}\n{weft_colors=}")
     try:
-        max_shaft_raised = max(max(shaft_set) for shaft_set in shaft_sets if shaft_set)
+        max_raised_shaft_number = max(max(shaft_set) for shaft_set in shaft_sets if shaft_set)
     except (ValueError, TypeError):
         raise RuntimeError("No shafts are raised") from None
-    all_shafts = set(range(1, max_shaft_raised + 1))
+    all_shafts = set(range(1, max_raised_shaft_number + 1))
     if data.is_rising_shed:
         shaft_words = [bitmask_from_bits(shaft_set) for shaft_set in shaft_sets]
     else:
@@ -519,7 +531,7 @@ def reduced_pattern_from_pattern_data(name: str, data: dtx_to_wif.PatternData) -
         threading=threading,
         picks=picks,
         tabby_picks=tabby_picks,
-        num_shafts=max(max_shaft_raised, max_threaded_shaft),
+        num_shafts=max(max_raised_shaft_number, max_threaded_shaft_number),
         separate_weaving_repeats=len(picks) > NUM_ITEMS_FOR_REPEAT_SEPARATOR,
         separate_threading_repeats=len(threading) > NUM_ITEMS_FOR_REPEAT_SEPARATOR,
     )

{base_loom_server-1.2b2 → base_loom_server-1.2b4}/src/base_loom_server/testutils.py

@@ -445,8 +445,9 @@ class Client:
         """
         expected_seen_types = {
             "CommandDone",
-            "CurrentPickNumber",
             "CurrentEndNumber",
+            "CurrentPickNumber",
+            "CurrentTabbyPickNumber",
             "ReducedPattern",
             "SeparateThreadingRepeats",
             "SeparateWeavingRepeats",
@@ -486,6 +487,8 @@ class Client:
                         repeat_number=pattern_in_reply.pick_repeat_number,
                         repeat_len=len(pattern_in_reply.picks),
                     )
+                case "CurrentTabbyPickNumber":
+                    assert reply.tabby_pick_number == pattern_in_reply.tabby_pick_number
                 case "CurrentEndNumber":
                     assert reply.end_number0 == pattern_in_reply.end_number0
                     assert reply.end_number1 == pattern_in_reply.end_number1

{base_loom_server-1.2b2 → base_loom_server-1.2b4}/src/base_loom_server/utils.py

@@ -1,6 +1,7 @@
 import asyncio
 import importlib
-from collections.abc import Iterable
+import itertools
+from collections.abc import Iterable, Sequence
 
 
 def bitmask_from_bits(bit_nums: Iterable[int]) -> int:
@@ -9,6 +10,7 @@ def bitmask_from_bits(bit_nums: Iterable[int]) -> int:
     Repeated values are ignored (naturally).
     """
     bit_set = set(bit_nums)
+
     return sum(1 << bit_num - 1 for bit_num in bit_set if bit_num > 0)
 
 
@@ -93,6 +95,13 @@ def get_version(package_name: str) -> str:
     return str(getattr(module, "__version__", "?"))
 
 
+def prune_duplicates(data: Sequence[int]) -> list[int]:
+    """Prune duplicate entries in an ordered sequence."""
+    if len(data) == 0:
+        return []
+    return [data[0]] + [val1 for val0, val1 in itertools.pairwise(data) if val1 != val0]
+
+
 async def run_shell_command(command: str) -> str:
     """Run a shell command and return the result.
 

{base_loom_server-1.2b2 → base_loom_server-1.2b4}/src/base_loom_server/version.py

@@ -1,3 +1,3 @@
 # Generated by setuptools_scm
 __all__ = ["__version__"]
-__version__ = "1.2b2"
+__version__ = "1.2b4"

{base_loom_server-1.2b2 → base_loom_server-1.2b4/src/base_loom_server.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: base_loom_server
-Version: 1.2b2
+Version: 1.2b4
 Summary: Base package for web servers that control dobby multi-shaft looms
 Author-email: Russell Owen <r3owen@gmail.com>
 Project-URL: Homepage, https://pypi.org/project/base-loom-server/

base_loom_server-1.2b4/tests/test_compute_tabby.py

@@ -0,0 +1,109 @@
+import pytest
+
+from base_loom_server.compute_tabby import (
+    compute_num_transitions,
+    compute_tabby_shaft_word1,
+    compute_tabby_shaft_word2,
+    compute_tabby_shaft_words,
+)
+
+# Dict of field name: default value
+EXPECTED_DEFAULTS = dict(
+    pick_number=0,
+    pick_repeat_number=1,
+    end_number0=0,
+    end_number1=0,
+    end_repeat_number=1,
+)
+
+
+def test_known_values() -> None:
+    """Get the shaft set for a specified 1-based pick_number."""
+    # Explicit values use 1-based shafts, for readability,
+    # but internally the threading array uses 0-based shafts.
+    for threading_1based, expected_shaft_word1, expected_num_transitions in (
+        # Fully interlaced
+        ([1, 2], 0b01, 0),
+        ([1, 2, 3, 4, 3, 2, 1], 0b0101, 0),
+        ([1, 2, 3, 4, 1, 2, 3], 0b0101, 0),
+        ([4, 3, 2, 1, 2, 3, 4], 0b0101, 0),
+        ([2, 3, 4, 5, 4, 3, 2], 0b01010, 0),
+        ([3, 4, 5, 6, 5, 4, 3], 0b010100, 0),
+        ([1, 10, 3, 6], 0b0000000101, 0),
+        ([2, 5, 4, 9], 0b000001010, 0),
+        ([2, 1, 2, 3, 4, 5], 0b10101, 0),
+        # Some repeating warp ends; ignoring those
+        # the fabric is fully interlaced.
+        ([6, 5, 4, 3, 3, 4, 5], 0b10100, 5),
+        ([5, 4, 3, 2, 2, 3, 4], 0b01010, 5),
+        ([1, 1, 2, 2], 0b01, 1),
+        ([1, 1, 1, 2, 2, 3, 3, 3], 0b101, 2),
+        # Overshot (perfect interlacemet)
+        ([1, 2, 1, 2, 3, 2, 3, 4, 3, 4, 1, 4, 1], 0b0101, 0),
+        # Bronson lace (perfect interlacemet)
+        ([1, 2, 1, 2, 1, 3, 1, 3, 1, 4, 1, 4], 0b0001, 0),
+        # Canvas weave
+        ([1, 2, 2, 1, 4, 3, 3, 4], 0b0101, 5),
+        # Non-trivial cases. The even warp ends and odd warp ends
+        # are not on unique sets of shafts (after purging repeating shafts).
+        # These are the only test cases that exercise the
+        # non-simple branch of the algorithm.
+        ([1, 2, 3, 1, 2, 3], 0b101, 4),
+        ([1, 2, 4, 2, 3, 1], 0b1101, 4),
+    ):
+        threading = [shaft - 1 for shaft in threading_1based]
+        if expected_num_transitions == 0:
+            expected_num_transitions = len(threading) - 1  # noqa: PLW2901
+
+        max_shaft_number = max(threading) + 1
+        expected_shaft_word2 = ~expected_shaft_word1 & (2**max_shaft_number - 1)
+
+        tabby_shaft_word1 = compute_tabby_shaft_word1(threading=threading)
+        tabby_shaft_word2 = compute_tabby_shaft_word2(
+            tabby_shaft_word1=tabby_shaft_word1, threading=threading
+        )
+        num_transitions = compute_num_transitions(tabby_shaft_word1, threading=threading)
+
+        if tabby_shaft_word1 != expected_shaft_word1 or num_transitions != expected_num_transitions:
+            print(  # noqa: T201
+                f"Failed for {threading_1based=}; {tabby_shaft_word1=:b}, "
+                f"{expected_shaft_word1=:b}, {num_transitions=}, {expected_num_transitions=}"
+            )
+
+        assert tabby_shaft_word1 == expected_shaft_word1
+        assert tabby_shaft_word2 == expected_shaft_word2
+        assert num_transitions == expected_num_transitions
+
+        assert expected_shaft_word1, expected_shaft_word2 == compute_tabby_shaft_words(threading)
+
+
+def test_invalid_values() -> None:
+    # Use 0-based threading here, as readability is less important
+    for threading in (
+        # Need at least two threaded warp ends
+        [],
+        [0],
+        [1],
+        # Need at least two different threaded shafts
+        [0, 0],
+        [1, 1],
+        [5, 5],
+    ):
+        with pytest.raises(ValueError):
+            compute_tabby_shaft_word1(threading=threading)
+        with pytest.raises(ValueError):
+            compute_tabby_shaft_words(threading=threading)
+        if len(threading) == 0:
+            # No warp ends are threaded
+            with pytest.raises(ValueError):
+                compute_tabby_shaft_word2(tabby_shaft_word1=0b1, threading=threading)
+        else:
+            # Raise no shafts on tabby 1
+            with pytest.raises(ValueError):
+                compute_tabby_shaft_word2(tabby_shaft_word1=0, threading=threading)
+
+            # Raise all shafts on tabby 1, so none are raised on tabby 2
+            max_threaded_shaft_number = max(threading) + 1
+            all_shafts_up = 2**max_threaded_shaft_number - 1
+            with pytest.raises(ValueError):
+                compute_tabby_shaft_word2(tabby_shaft_word1=all_shafts_up, threading=threading)

{base_loom_server-1.2b2 → base_loom_server-1.2b4}/tests/test_utils.py

@@ -8,6 +8,7 @@ from base_loom_server.utils import (
     compute_num_within_and_repeats,
     compute_total_num,
     get_version,
+    prune_duplicates,
 )
 
 
@@ -39,20 +40,6 @@ def test_bitmask_functions() -> None:
         assert bitmask == bitmask_from_bits(bits)
 
 
-def test_compute_total_num() -> None:
-    for num_within, repeat_number, repeat_len in itertools.product(
-        (-50, -33, -1, 0, 1, 33, 50), (-1, 0, 1), (1, 21, 33, 50)
-    ):
-        total_num = compute_total_num(num_within, repeat_number, repeat_len)
-        assert total_num == (repeat_number - 1) * repeat_len + num_within
-
-        with pytest.raises(ValueError):
-            compute_total_num(num_within, repeat_number, 0)
-
-        with pytest.raises(ValueError):
-            compute_total_num(num_within, repeat_number, -1)
-
-
 def test_compute_num_within_and_repeats() -> None:
     for num_within, repeat_number, repeat_len in itertools.product(
         (-50, -33, -1, 0, 1, 33, 50), (-1, 0, 1), (1, 21, 33, 50)
@@ -83,6 +70,20 @@ def test_compute_num_within_and_repeats() -> None:
             compute_num_within_and_repeats(total_num, -1)
 
 
+def test_compute_total_num() -> None:
+    for num_within, repeat_number, repeat_len in itertools.product(
+        (-50, -33, -1, 0, 1, 33, 50), (-1, 0, 1), (1, 21, 33, 50)
+    ):
+        total_num = compute_total_num(num_within, repeat_number, repeat_len)
+        assert total_num == (repeat_number - 1) * repeat_len + num_within
+
+        with pytest.raises(ValueError):
+            compute_total_num(num_within, repeat_number, 0)
+
+        with pytest.raises(ValueError):
+            compute_total_num(num_within, repeat_number, -1)
+
+
 def test_get_version() -> None:
     assert get_version("#_invalid_package_name") == "?"
 
@@ -92,3 +93,22 @@ def test_get_version() -> None:
         assert get_version("base_loom_server") == "?"
     else:
         assert get_version("base_loom_server") == getattr(version, "__version__", "?")
+
+
+def test_prune_duplicates() -> None:
+    for data in (
+        [],
+        [1, 1, 1, 2, 3, 3, 0, 3, 2, -1, -1],
+        [-1, 2, 0, 1],
+        [0, 55, 55, 22, 22, -1, -1, 55],
+    ):
+        pruned_data = prune_duplicates(data)
+        # compare to a different implementation
+        desired_pruned_data: list[int] = []
+        prev_val: int | None = None
+        for end in data:
+            if end != prev_val:
+                prev_val = end
+                desired_pruned_data.append(end)
+
+        assert pruned_data == desired_pruned_data

base_loom_server-1.2b2/src/base_loom_server/compute_tabby.py

@@ -1,183 +0,0 @@
-from itertools import pairwise
-
-# Maximum starting points for walking through the threading
-# in compute_tabby_shaft_word1. This keeps the compute time sane.
-MAX_ITER = 5
-
-
-def compute_num_transitions(tabby_shaft_word: int, threading: list[int]) -> int:
-    """Compute the number of transitions produced by a tabby shaft word.
-
-    The largest possible value is len(threading_shaft_words) - 1.
-
-    Args:
-        tabby_shaft_word: Tabby shaft word.
-        threading: Which shaft each warp end is on.
-    """
-    threading_shaft_words = [1 << (shaft - 1) for shaft in threading if shaft > 0]
-    return _basic_compute_num_transitions(
-        tabby_shaft_word=tabby_shaft_word, threading_shaft_words=threading_shaft_words
-    )
-
-
-def _basic_compute_num_transitions(tabby_shaft_word: int, threading_shaft_words: list[int]) -> int:
-    """Implementation of compute_num_transitions.
-
-    Args:
-        tabby_shaft_word: Tabby shaft word.
-        threading_shaft_words: Shaft word for each warp end.
-    """
-    is_up_list = [bool(tsw & tabby_shaft_word) for tsw in threading_shaft_words]
-    return sum(1 for val1, val2 in pairwise(is_up_list) if val1 != val2)
-
-
-def compute_tabby_shaft_word1(threading: list[int]) -> int:
-    """Compute which shaft_set should go up for the best tabby pick 1.
-
-    Args:
-        threading: List of 1-based shaft number for each warp end.
-            Ends with shaft < 1 are ignored.
-
-    Returns:
-        shaft_word: Which shaft_set should be up for pick 1, 3, 5... of tabby.
-
-    Raises:
-        ValueError if there are fewer than 2 threaded warp ends,
-            or if the warp ends are threaded on fewer than 2 different shaft_set.
-
-    Notes:
-        The algorithm is as follows:
-
-        First make a pruned version of the threading with no 0s
-        (warp ends that are not threaded) and no repeating ends.
-
-        Now check the most common case: if all even (pruned) warp ends
-        are threaded on a separate set of shafts than all odd warp ends,
-        (a case that allows optimal interlacement) then return
-        a tabby shaft word that raises every shaft in the odd warp ends set.
-
-        If that fails, use a harder and less ideal algorithm:
-        Loop through the (pruned) warp ends. For each shaft that
-        has not been seen before, append it to a list of seen shafts.
-        Then make a tabby shaft word that raises every other shaft
-        of the seen shafts.
-
-        Try this several times, from different starting points
-        in the threading, and pick the tabby shaft word that gives
-        the most consecutive transitions.
-    """
-    nonzero_threading = [shaft for shaft in threading if shaft > 0]
-    num_threaded_shafts = len(set(nonzero_threading))
-    if len(nonzero_threading) <= 1:
-        raise ValueError("Need at least 2 threaded warp ends to weave tabby.")
-    if num_threaded_shafts <= 1:
-        raise ValueError("Need at least 2 threaded shafts to weave tabby.")
-
-    # Prune repeating duplicate ends
-    pruned_threading: list[int] = []
-    prev_end = 0
-    for end in nonzero_threading:
-        if end != prev_end:
-            prev_end = end
-            pruned_threading.append(end)
-
-    # Try the common case that the odd warp ends are on one set of shafts
-    # and the even warp ends are on another set of shafts, with no overlap
-    odd_ends_shaft_set = set(pruned_threading[::2])
-    even_ends_shaft_set = set(pruned_threading[1::2])
-    if even_ends_shaft_set & odd_ends_shaft_set == set():
-        tabby_shaft_word = 0
-        for shaft in odd_ends_shaft_set:
-            tabby_shaft_word |= 1 << (shaft - 1)
-        return tabby_shaft_word
-
-    # Try the harder and less ideal algorithm.
-    threading_shaft_words = [1 << (shaft - 1) for shaft in threading if shaft > 0]
-
-    best_num_transitions = 0
-    best_tabby_shaft_word = 0
-
-    # Try starting at several different points in the threading,
-    # in order to get a somewhat better result.
-    num_threads = len(pruned_threading)
-    start_interval = ((num_threads - 1) // MAX_ITER) + 1
-    if num_threads < MAX_ITER * 2:
-        # Not many threads; don't worry about limiting the number of iterations.
-        start_interval = 1
-    niter = 0
-    for start_index in range(0, num_threads, start_interval):
-        niter += 1
-        seen_shaft_set: set[int] = set()
-        seen_shaft_arr: list[int] = []
-        for shaft in pruned_threading[start_index:] + pruned_threading[:start_index]:
-            if shaft in seen_shaft_set:
-                continue
-            seen_shaft_set.add(shaft)
-            seen_shaft_arr.append(shaft)
-            if len(seen_shaft_set) == num_threaded_shafts:
-                # We have seen all the shafts; stop
-                break
-
-        tabby_shaft_word = 0
-        for shaft in seen_shaft_arr[::2]:
-            tabby_shaft_word |= 1 << (shaft - 1)
-
-        num_transitions = _basic_compute_num_transitions(
-            tabby_shaft_word=tabby_shaft_word, threading_shaft_words=threading_shaft_words
-        )
-        if num_transitions > best_num_transitions:
-            best_num_transitions = num_transitions
-            best_tabby_shaft_word = tabby_shaft_word
-            if num_transitions == len(pruned_threading) - 1:
-                # Unlikely, since the simple case failed
-                # but it's quick to check and we can't do better
-                break
-    return best_tabby_shaft_word
-
-
-def compute_tabby_shaft_word2(tabby_shaft_word1: int, max_threaded_shaft: int) -> int:
-    """Compute tabby_shaft_word2 as the complement of tabby_shaft_word1.
-
-    Args:
-        tabby_shaft_word1: tabby shaft word computed by compute_tabby_shaft_word1.
-        max_threaded_shaft: max(threading); the maximum shaft number (1-based)
-            that has any warp strings threaded on it. All bits beyond that
-            will be 0.
-
-    Returns:
-        tabby_shaft_word2: which shaft_set should be up picks 2, 4, 6... of tabby.
-            The complement tabby_shaft_word1, will all shaft_set beyond max_threaded_shaft
-            set to 0.
-
-    Raises:
-        ValueError if max_threaded_shaft < 2.
-    """
-    if tabby_shaft_word1 < 1:
-        raise ValueError(f"{tabby_shaft_word1=} must be positive")
-    if max_threaded_shaft <= 1:
-        raise ValueError(f"{max_threaded_shaft=} must be > 1")
-    all_shaft_set_mask = (1 << max_threaded_shaft) - 1
-    return ~tabby_shaft_word1 & all_shaft_set_mask
-
-
-def compute_tabby_shaft_words(threading: list[int]) -> tuple[int, int]:
-    """Compute tabby_shaft_words 1 and 2.
-
-    Args:
-        threading: List of 1-based shaft number for each warp end.
-            Ends with shaft < 1 are ignored.
-
-    Returns:
-        (shaft_word1, shaft_word2): Which shaft_set should be up for the two picks of tabby
-            (word 1 is for picks 1, 3, 5.., word 2 is for picks 2, 4, 6...).
-
-    Raises:
-        ValueError if there are fewer than 2 threaded warp ends,
-            or if the warp ends are threaded on fewer than 2 different shaft_set.
-    """
-    tabby_shaft_word1 = compute_tabby_shaft_word1(threading=threading)
-    max_threaded_shaft = max(threading)
-    tabby_shaft_word2 = compute_tabby_shaft_word2(
-        tabby_shaft_word1=tabby_shaft_word1, max_threaded_shaft=max_threaded_shaft
-    )
-    return (tabby_shaft_word1, tabby_shaft_word2)

base_loom_server-1.2b2/tests/test_compute_tabby.py

@@ -1,98 +0,0 @@
-import itertools
-
-import pytest
-
-from base_loom_server.compute_tabby import (
-    compute_num_transitions,
-    compute_tabby_shaft_word1,
-    compute_tabby_shaft_word2,
-    compute_tabby_shaft_words,
-)
-
-# Dict of field name: default value
-EXPECTED_DEFAULTS = dict(
-    pick_number=0,
-    pick_repeat_number=1,
-    end_number0=0,
-    end_number1=0,
-    end_repeat_number=1,
-)
-
-
-def test_known_values() -> None:
-    """Get the shaft set for a specified 1-based pick_number."""
-    for threading, expected_shaft_word1, expected_shaft_word2, expected_num_transitions in (
-        # Fully interlaced
-        ([1, 2], 0b01, 0b10, 0),
-        ([1, 2, 3, 4, 3, 2, 1], 0b0101, 0b1010, 0),
-        ([1, 2, 3, 4, 1, 2, 3], 0b0101, 0b1010, 0),
-        ([4, 3, 2, 1, 2, 3, 4], 0b1010, 0b0101, 0),
-        ([2, 3, 4, 5, 4, 3, 2], 0b01010, 0b10101, 0),
-        ([3, 4, 5, 6, 5, 4, 3], 0b010100, 0b101011, 0),
-        ([1, 10, 3, 6], 0b0000000101, 0b1111111010, 0),
-        ([2, 5, 4, 9], 0b000001010, 0b111110101, 0),
-        ([2, 1, 2, 3, 4, 5], 0b01010, 0b10101, 0),
-        # Some repeating warp ends; ignoring those
-        # the fabric is fully interlaced.
-        ([6, 5, 4, 3, 3, 4, 5], 0b101000, 0b010111, 5),
-        ([5, 4, 3, 2, 2, 3, 4], 0b10100, 0b01011, 5),
-        ([1, 1, 2, 2], 0b01, 0b10, 1),
-        ([1, 1, 1, 2, 2, 3, 3, 3], 0b101, 0b010, 2),
-        # Overshot (perfect interlacemet)
-        ([1, 2, 1, 2, 3, 2, 3, 4, 3, 4, 1, 4, 1], 0b0101, 0b1010, 0),
-        # Bronson lace (perfect interlacemet)
-        ([1, 2, 1, 2, 1, 3, 1, 3, 1, 4, 1, 4], 0b0001, 0b1110, 0),
-        # Canvas weave
-        ([1, 2, 2, 1, 4, 3, 3, 4], 0b0101, 0b1010, 5),
-        # Non-trivial cases. The even warp ends and odd warp ends
-        # are not on unique sets of shafts (after purging repeating shafts).
-        # These are the only test cases that exercise the
-        # non-simple branch of the algorithm.
-        ([1, 2, 3, 1, 2, 3], 0b101, 0b010, 4),
-        ([1, 2, 4, 2, 3, 1], 0b1001, 0b0110, 4),
-    ):
-        if expected_num_transitions == 0:
-            expected_num_transitions = len(threading) - 1  # noqa: PLW2901
-
-        tabby_shaft_word1 = compute_tabby_shaft_word1(threading=threading)
-
-        max_threaded_shaft = max(threading)
-        tabby_shaft_word2 = compute_tabby_shaft_word2(
-            tabby_shaft_word1=tabby_shaft_word1, max_threaded_shaft=max_threaded_shaft
-        )
-
-        num_transitions = compute_num_transitions(tabby_shaft_word1, threading=threading)
-
-        assert tabby_shaft_word1 == expected_shaft_word1
-        assert tabby_shaft_word2 == expected_shaft_word2
-        assert num_transitions == expected_num_transitions
-
-        assert expected_shaft_word1, expected_shaft_word2 == compute_tabby_shaft_words(threading)
-
-
-def test_invalid_values() -> None:
-    for threading in (
-        # Need at least two threaded warp ends
-        [],
-        [0],
-        [1],
-        [0, 0],
-        [0, 1],
-        [1, 0],
-        # Need at least two different threaded shafts
-        [1, 1],
-        [5, 5],
-    ):
-        with pytest.raises(ValueError):
-            compute_tabby_shaft_word1(threading=threading)
-        with pytest.raises(ValueError):
-            compute_tabby_shaft_words(threading=threading)
-
-    for tabby_shaft_word1, max_threaded_shaft in itertools.product((-1, 0, 1, 2), (-1, 0, 1, 2, 3)):
-        if tabby_shaft_word1 > 0 and max_threaded_shaft > 1:
-            # A valid combination
-            continue
-        with pytest.raises(ValueError):
-            compute_tabby_shaft_word2(
-                tabby_shaft_word1=tabby_shaft_word1, max_threaded_shaft=max_threaded_shaft
-            )