pd-code-pre-nxt 0.0.1__tar.gz → 0.1.1__tar.gz

pd_code_pre_nxt-0.1.1/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: pd-code-pre-nxt
+Version: 0.1.1
+Summary: get `pre` and `next` node for every number in pd_code.
+License: MIT
+License-File: LICENSE
+Author: GGN_2015
+Author-email: neko@jlulug.org
+Requires-Python: >=3.10
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: pd-code-sanity (>=0.1.0)
+Description-Content-Type: text/markdown
+
+# pd-code-pre-nxt
+
+Build deterministic predecessor and successor maps for every PD-code arc label.
+
+## Installation
+
+```bash
+pip install pd-code-pre-nxt
+```
+
+## Usage example
+
+```python
+from pd_code_pre_nxt import get_pre_nxt
+
+pd = [[1, 5, 2, 4], [3, 1, 4, 6], [5, 3, 6, 2]]
+pre, nxt = get_pre_nxt(pd)
+print(nxt[1], pre[1])
+```
+
+## Algorithm
+
+Opposite crossing slots define the component graph. Each component must be a two-regular cycle, with a special deterministic treatment for two-label cycles. The smallest label is chosen as the cycle start; both traversal directions are compared lexicographically and the canonical one defines `pre` and `nxt`. Numeric suffixes are supported for temporary prefixed labels used during connected sums.
+
+## Input conventions
+
+A PD code is represented as a list of four-entry crossings. Arc labels normally occur exactly twice. Public functions validate inputs and return new values rather than mutating caller-owned data unless their API explicitly says otherwise.
+
+## External software
+
+No external software is required.
+
+## Development
+
+Run examples and package checks before release. Python packages require Python 3.10 or newer. Build PyPI artifacts with:
+
+```bash
+poetry check
+poetry build
+```
+
+## License
+
+MIT. See `LICENSE`.
+

pd_code_pre_nxt-0.1.1/README.md

@@ -0,0 +1,44 @@
+# pd-code-pre-nxt
+
+Build deterministic predecessor and successor maps for every PD-code arc label.
+
+## Installation
+
+```bash
+pip install pd-code-pre-nxt
+```
+
+## Usage example
+
+```python
+from pd_code_pre_nxt import get_pre_nxt
+
+pd = [[1, 5, 2, 4], [3, 1, 4, 6], [5, 3, 6, 2]]
+pre, nxt = get_pre_nxt(pd)
+print(nxt[1], pre[1])
+```
+
+## Algorithm
+
+Opposite crossing slots define the component graph. Each component must be a two-regular cycle, with a special deterministic treatment for two-label cycles. The smallest label is chosen as the cycle start; both traversal directions are compared lexicographically and the canonical one defines `pre` and `nxt`. Numeric suffixes are supported for temporary prefixed labels used during connected sums.
+
+## Input conventions
+
+A PD code is represented as a list of four-entry crossings. Arc labels normally occur exactly twice. Public functions validate inputs and return new values rather than mutating caller-owned data unless their API explicitly says otherwise.
+
+## External software
+
+No external software is required.
+
+## Development
+
+Run examples and package checks before release. Python packages require Python 3.10 or newer. Build PyPI artifacts with:
+
+```bash
+poetry check
+poetry build
+```
+
+## License
+
+MIT. See `LICENSE`.

pd_code_pre_nxt-0.1.1/pd_code_pre_nxt/main.py

@@ -0,0 +1,74 @@
+import re
+
+import pd_code_sanity
+
+
+def get_raw_val(value: int | str) -> int:
+    if isinstance(value, bool):
+        raise TypeError("boolean labels are not valid")
+    if isinstance(value, int):
+        return value
+    match = re.search(r"(-?\d+)$", value)
+    if not match:
+        raise ValueError(f"label has no numeric suffix: {value!r}")
+    return int(match.group(1))
+
+
+def get_num_set(pd_code: list[list]) -> list:
+    return sorted({label for crossing in pd_code for label in crossing}, key=get_raw_val)
+
+
+def _canonical_cycle(component: set, adjacency: dict) -> list:
+    start = min(component, key=get_raw_val)
+    neighbors = list(adjacency[start])
+    if len(component) == 2:
+        return [start, neighbors[0]]
+    if len(neighbors) != 2:
+        raise ValueError("PD component graph is not a cycle")
+
+    candidates = []
+    for first in neighbors:
+        cycle = [start]
+        previous, current = start, first
+        while current != start:
+            if current in cycle:
+                raise ValueError("PD component graph contains a short cycle")
+            cycle.append(current)
+            next_nodes = adjacency[current] - {previous}
+            if len(next_nodes) != 1:
+                raise ValueError("PD component graph is not 2-regular")
+            previous, current = current, next(iter(next_nodes))
+        if len(cycle) != len(component):
+            raise ValueError("PD component graph is disconnected")
+        candidates.append(cycle)
+    return min(candidates, key=lambda cycle: [get_raw_val(item) for item in cycle])
+
+
+def get_pre_nxt(pd_code: list[list]) -> tuple[dict, dict]:
+    """Build deterministic predecessor/successor maps from PD topology."""
+    if not pd_code_sanity.sanity(pd_code):
+        raise ValueError("invalid PD code")
+
+    adjacency: dict = {}
+    for crossing in pd_code:
+        for a, b in ((crossing[0], crossing[2]), (crossing[1], crossing[3])):
+            adjacency.setdefault(a, set()).add(b)
+            adjacency.setdefault(b, set()).add(a)
+
+    pre, nxt, seen = {}, {}, set()
+    for start in get_num_set(pd_code):
+        if start in seen:
+            continue
+        stack, component = [start], set()
+        while stack:
+            node = stack.pop()
+            if node in component:
+                continue
+            component.add(node)
+            stack.extend(adjacency[node] - component)
+        cycle = _canonical_cycle(component, adjacency)
+        seen.update(component)
+        for index, node in enumerate(cycle):
+            pre[node] = cycle[index - 1]
+            nxt[node] = cycle[(index + 1) % len(cycle)]
+    return pre, nxt

{pd_code_pre_nxt-0.0.1 → pd_code_pre_nxt-0.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pd-code-pre-nxt"
-version = "0.0.1"
+version = "0.1.1"
 description = "get `pre` and `next` node for every number in pd_code."
 authors = [
     {name = "GGN_2015",email = "neko@jlulug.org"}
@@ -8,9 +8,9 @@ authors = [
 license = {text = "MIT"}
 readme = "README.md"
 requires-python = ">=3.10"
-dependencies = [
-    
-]
+dependencies = [
+    "pd-code-sanity>=0.1.0"
+]
 
 
 [build-system]

pd_code_pre_nxt-0.0.1/PKG-INFO

@@ -1,44 +0,0 @@
-Metadata-Version: 2.4
-Name: pd-code-pre-nxt
-Version: 0.0.1
-Summary: get `pre` and `next` node for every number in pd_code.
-License: MIT
-License-File: LICENSE
-Author: GGN_2015
-Author-email: neko@jlulug.org
-Requires-Python: >=3.10
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
-Description-Content-Type: text/markdown
-
-# pd_code_pre_nxt
-get `pre` and `next` node for every number in pd_code.
-
-## Install
-
-```bash
-pip install pd-code-pre-nxt
-```
-
-## Usage
-
-```python
-import pd_code_pre_nxt
-
-# link pd_code
-pd_code = [[1, 5, 2, 4], [3, 1, 4, 6], [5, 3, 6, 2]]
-
-# output number set (ascending order)
-print(pd_code_pre_nxt.get_num_set(pd_code))
-
-# get pre, nxt dict for pd_code
-pre, nxt = pd_code_pre_nxt.get_pre_nxt(pd_code)
-print(pre)
-print(nxt)
-```
-

pd_code_pre_nxt-0.0.1/README.md

@@ -1,25 +0,0 @@
-# pd_code_pre_nxt
-get `pre` and `next` node for every number in pd_code.
-
-## Install
-
-```bash
-pip install pd-code-pre-nxt
-```
-
-## Usage
-
-```python
-import pd_code_pre_nxt
-
-# link pd_code
-pd_code = [[1, 5, 2, 4], [3, 1, 4, 6], [5, 3, 6, 2]]
-
-# output number set (ascending order)
-print(pd_code_pre_nxt.get_num_set(pd_code))
-
-# get pre, nxt dict for pd_code
-pre, nxt = pd_code_pre_nxt.get_pre_nxt(pd_code)
-print(pre)
-print(nxt)
-```

pd_code_pre_nxt-0.0.1/pd_code_pre_nxt/main.py

@@ -1,77 +0,0 @@
-import pd_code_sanity
-
-# 提取原始数值
-# 如果里面有下划线，则去掉下划线转 int
-def get_raw_val(val_in_crs:int|str) -> int:
-    if isinstance(val_in_crs, str):
-        return int(val_in_crs.split("_")[-1])
-    return int(val_in_crs)
-
-def add_edge(pre:dict, nxt:dict, val1, val2):
-    raw_val1 = get_raw_val(val1)
-    raw_val2 = get_raw_val(val2)
-
-    # 记录前后关系
-    pre_val = -1
-    nxt_val = -1
-
-    # 确定前后关系
-    if abs(raw_val1 - raw_val2) == 1:
-        if raw_val1 < raw_val2:
-            pre_val = val1
-            nxt_val = val2
-        else:
-            pre_val = val2
-            nxt_val = val1
-    else:
-        if raw_val1 < raw_val2:
-            pre_val = val2
-            nxt_val = val1
-        else:
-            pre_val = val1
-            nxt_val = val2
-
-    # 设置 dict 值 
-    pre[nxt_val] = pre_val
-    nxt[pre_val] = nxt_val
-
-# 获得 pd_code 中的数值集合
-# 按照字典序从小到大排序
-def get_num_set(pd_code:list[list]):
-    val_set = set()
-    for crossing in pd_code:
-        for term in crossing:
-            if term not in val_set:
-                val_set.add(term)
-    return sorted(list(val_set), key=lambda x:get_raw_val(x))
-
-# 计算 pre 和 nxt
-# 没有 r1 crossing 就不会出现混乱
-def get_pre_nxt(pd_code:list[list]) -> tuple[dict, dict]:
-
-    # 检查类型是否正确
-    if not pd_code_sanity.sanity(pd_code):
-        raise TypeError()
-
-    pre = dict()
-    nxt = dict()
-    for crossing in pd_code:
-        if len(set(crossing)) > 2: # 至少有三个不同的数
-            add_edge(pre, nxt, crossing[0], crossing[2])
-            add_edge(pre, nxt, crossing[1], crossing[3])
-        else:
-            two_values = list(set(crossing)) # 只有两个不同的数
-            if len(two_values) != 2:
-                raise AssertionError()
-            for i in range(2):
-                pre[two_values[i]] = two_values[1-i] # 互为前驱后继
-                nxt[two_values[i]] = two_values[1-i]
-    
-    # 获取数值合集
-    num_set = get_num_set(pd_code)
-    for num in num_set:
-        if pre.get(num) is None:
-            pre[num] = nxt[num]
-        if nxt.get(num) is None:
-            nxt[num] = pre[num]
-    return pre, nxt