link-rep 0.0.1__tar.gz

link_rep-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 TopologicalKnotIndexer
+
+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.

link_rep-0.0.1/PKG-INFO

@@ -0,0 +1,156 @@
+Metadata-Version: 2.4
+Name: link-rep
+Version: 0.0.1
+Summary: representation for a composite topological link.
+License: MIT
+License-File: LICENSE
+Author: GGN_2015
+Author-email: premierbob@qq.com
+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: typing_extensions
+Description-Content-Type: text/markdown
+
+# LinkRep
+A Cross-Platform Universal Representation for Composite Links
+
+## Installation
+
+```bash
+pip install link-rep
+```
+
+## Usage
+
+```python
+from link_rep import LinkRep
+
+real_serial = ( # human readable presentation
+"""
+// this is comment line 1
+// this is comment line 2
+L2a1: [[4, 1, 3, 2], [2, 3, 1, 4]]
+L4a1: [[6, 1, 7, 2], [8, 3, 5, 4], [2, 5, 3, 6], [4, 7, 1, 8]]
+K3a1: [[1, 5, 2, 4], [3, 1, 4, 6], [5, 3, 6, 2]]
+[L2a1, L4a1, K3a1]
+L[1, 1]#L[2, 1]
+L[2, 2]#L[3, 1]
+""").lstrip()
+
+link_r = LinkRep()
+link_r.deserialize(real_serial)
+
+print(link_r.json_serialize()) # machine readable presentation
+print(link_r.serialize())      # human readable presentation
+
+json_str = link_r.json_serialize()
+new_link_r = LinkRep()
+new_link_r.json_deserialize(json_str) # get data from json serial
+```
+
+## LinkRep Format
+
+The content of LinkRep consists of four parts:
+
+1. Comment Lines: Lines starting with `//`, as well as lines containing only whitespace characters, are comment lines. Lines containing only whitespace should be ignored during parsing, while comment lines should be retained as informational content.
+
+2. Variable Definitions (VarDef): Used to define variables that represent PdCodes (Planar Diagram Codes), for example:
+
+```
+L2a1: [[4, 1, 3, 2], [2, 3, 1, 4]]
+```
+
+The above statement defines a variable named `L2a1` that stores a PdCode `[[4, 1, 3, 2], [2, 3, 1, 4]]`. The variable name (VarName) should be a string composed of letters, numbers, and underscores, and must not start with a number. Multiple variables with different names can be defined.
+
+While the rules allow arbitrary variable naming, in practice it is recommended to use standard knot or link names to name PdCodes. Warnings should be issued for variable definitions using non-standard PdCodes.
+
+3. Link Set Description (LinkSet): A sequence of variable names describing all links used, where the order affects subsequent usage. This description can only appear once in LinkRep.
+
+```
+[L2a1, L4a1, K3a1]
+```
+
+This line describes the knot information before performing connected sums. In the connection method descriptor, `L[i, j]` is used to denote the j-th connected component of the i-th link variable. Both `i` and `j` are numbered starting from 1 and increment upwards.
+
+4. Connection Method Descriptor (LinkMethod): Describes which connected components of which links should be connected together, for example:
+
+```
+L[1, 1]#L[2, 2]
+```
+
+This can be used to indicate that the first connected component of the first link should be connected (via connected sum) with the second connected component of the second link.
+
+```
+L[1, 2]#L[2, 2]#L[3, 1]
+```
+
+This can be used to indicate that the second connected component of the first link should be connected (via connected sum) with the second connected component of the second link, and this connected component should then be connected (via connected sum) with the first connected component of the third link.
+
+## Formal Definition
+
+Lexical Units:
+```
+CommentLine => "//[^\n]*\n"
+VarName => "[A-Za-z_][A-Za-z0-9_]*"
+PdCode  => "(\[\])|(\[\[\d+,\s*\d+,\s*\d+,\s*\d+\](,\[\d+,\s*\d+,\s*\d+,\s*\d+\])*\])"
+PosName => "L\[\d+,\s*\d+\]"
+```
+
+VarLine: Defines a single variable
+```
+VarLine -> VarName ":" PdCode "\n"
+```
+
+VarDef: Defines all variables
+```
+VarDef -> VarLine
+VarDef -> VarLine VarDef
+```
+
+VarNameList: List of variable names
+```
+VarNameList -> VarName
+VarNameList -> VarName "," VarNameList
+```
+
+LinkSet: Defines all links to be used
+```
+LinkSet -> "[" VarNameList "]" "\n"
+```
+
+LinkLineList: Connects connected components without line breaks
+```
+LinkLineList -> PosName "#" PosName
+LinkLineList -> PosName "#" PosName "#" LinkLineList
+```
+
+LinkLine: Describes the connection of connected components
+```
+LinkLine -> LinkLineList "\n"
+```
+
+LinkMethod: Describes the connection of connected components
+```
+LinkMethod ->
+LinkMethod -> LinkLine
+LinkMethod -> LinkLine LinkMethod
+```
+
+Comment:
+```
+Comment ->
+Comment -> CommentLine
+Comment -> CommentLine Comment
+```
+
+LinkRep:
+```
+LinkRep -> Comment VarDef LinkSet LinkMethod
+```
+

link_rep-0.0.1/README.md

@@ -0,0 +1,136 @@
+# LinkRep
+A Cross-Platform Universal Representation for Composite Links
+
+## Installation
+
+```bash
+pip install link-rep
+```
+
+## Usage
+
+```python
+from link_rep import LinkRep
+
+real_serial = ( # human readable presentation
+"""
+// this is comment line 1
+// this is comment line 2
+L2a1: [[4, 1, 3, 2], [2, 3, 1, 4]]
+L4a1: [[6, 1, 7, 2], [8, 3, 5, 4], [2, 5, 3, 6], [4, 7, 1, 8]]
+K3a1: [[1, 5, 2, 4], [3, 1, 4, 6], [5, 3, 6, 2]]
+[L2a1, L4a1, K3a1]
+L[1, 1]#L[2, 1]
+L[2, 2]#L[3, 1]
+""").lstrip()
+
+link_r = LinkRep()
+link_r.deserialize(real_serial)
+
+print(link_r.json_serialize()) # machine readable presentation
+print(link_r.serialize())      # human readable presentation
+
+json_str = link_r.json_serialize()
+new_link_r = LinkRep()
+new_link_r.json_deserialize(json_str) # get data from json serial
+```
+
+## LinkRep Format
+
+The content of LinkRep consists of four parts:
+
+1. Comment Lines: Lines starting with `//`, as well as lines containing only whitespace characters, are comment lines. Lines containing only whitespace should be ignored during parsing, while comment lines should be retained as informational content.
+
+2. Variable Definitions (VarDef): Used to define variables that represent PdCodes (Planar Diagram Codes), for example:
+
+```
+L2a1: [[4, 1, 3, 2], [2, 3, 1, 4]]
+```
+
+The above statement defines a variable named `L2a1` that stores a PdCode `[[4, 1, 3, 2], [2, 3, 1, 4]]`. The variable name (VarName) should be a string composed of letters, numbers, and underscores, and must not start with a number. Multiple variables with different names can be defined.
+
+While the rules allow arbitrary variable naming, in practice it is recommended to use standard knot or link names to name PdCodes. Warnings should be issued for variable definitions using non-standard PdCodes.
+
+3. Link Set Description (LinkSet): A sequence of variable names describing all links used, where the order affects subsequent usage. This description can only appear once in LinkRep.
+
+```
+[L2a1, L4a1, K3a1]
+```
+
+This line describes the knot information before performing connected sums. In the connection method descriptor, `L[i, j]` is used to denote the j-th connected component of the i-th link variable. Both `i` and `j` are numbered starting from 1 and increment upwards.
+
+4. Connection Method Descriptor (LinkMethod): Describes which connected components of which links should be connected together, for example:
+
+```
+L[1, 1]#L[2, 2]
+```
+
+This can be used to indicate that the first connected component of the first link should be connected (via connected sum) with the second connected component of the second link.
+
+```
+L[1, 2]#L[2, 2]#L[3, 1]
+```
+
+This can be used to indicate that the second connected component of the first link should be connected (via connected sum) with the second connected component of the second link, and this connected component should then be connected (via connected sum) with the first connected component of the third link.
+
+## Formal Definition
+
+Lexical Units:
+```
+CommentLine => "//[^\n]*\n"
+VarName => "[A-Za-z_][A-Za-z0-9_]*"
+PdCode  => "(\[\])|(\[\[\d+,\s*\d+,\s*\d+,\s*\d+\](,\[\d+,\s*\d+,\s*\d+,\s*\d+\])*\])"
+PosName => "L\[\d+,\s*\d+\]"
+```
+
+VarLine: Defines a single variable
+```
+VarLine -> VarName ":" PdCode "\n"
+```
+
+VarDef: Defines all variables
+```
+VarDef -> VarLine
+VarDef -> VarLine VarDef
+```
+
+VarNameList: List of variable names
+```
+VarNameList -> VarName
+VarNameList -> VarName "," VarNameList
+```
+
+LinkSet: Defines all links to be used
+```
+LinkSet -> "[" VarNameList "]" "\n"
+```
+
+LinkLineList: Connects connected components without line breaks
+```
+LinkLineList -> PosName "#" PosName
+LinkLineList -> PosName "#" PosName "#" LinkLineList
+```
+
+LinkLine: Describes the connection of connected components
+```
+LinkLine -> LinkLineList "\n"
+```
+
+LinkMethod: Describes the connection of connected components
+```
+LinkMethod ->
+LinkMethod -> LinkLine
+LinkMethod -> LinkLine LinkMethod
+```
+
+Comment:
+```
+Comment ->
+Comment -> CommentLine
+Comment -> CommentLine Comment
+```
+
+LinkRep:
+```
+LinkRep -> Comment VarDef LinkSet LinkMethod
+```

link_rep-0.0.1/link_rep/Comment.py

@@ -0,0 +1,68 @@
+from typing_extensions import override
+import json
+
+try:
+    from .LinkRepMetaObject import LinkRepMetaObject
+except:
+    from LinkRepMetaObject import LinkRepMetaObject
+
+# 注释部分：记录每一行的注释信息
+# 存储的注释信息中不含 "//" 与行末的换行符
+class Comment(LinkRepMetaObject):
+    def __init__(self) -> None:
+        super().__init__()
+        self.msg_list = []
+
+    # 设置注释内容
+    def set_msg_list(self, new_msg_list:list[str]):
+        # 需要删除所有换行符
+        self.msg_list = list(map(
+            lambda line: line.replace("\n", ""),
+            new_msg_list
+        ))
+
+    @override
+    def serialize(self) -> str:
+        return "".join(list(map(
+            lambda line: "//" + line + "\n",
+            self.msg_list
+        )))
+    
+    @override
+    def deserialize(self, s:str) -> None:
+        self.set_msg_list([
+            item[2:]
+            for item in s.split("\n")
+            if item.startswith("//")
+        ])
+
+    @override
+    def json_serialize(self) -> str:
+        return json.dumps({
+            "type": "Comment",
+            "msg_list": self.msg_list
+        })
+    
+    @override
+    def json_deserialize(self, s:str) -> None:
+        obj_now = json.loads(s)
+
+        # 控制类型
+        if obj_now.get("type") != "Comment":
+            raise AssertionError()
+        
+        # 必须包含完整信息
+        if not isinstance(obj_now.get("msg_list"), list):
+            raise AssertionError()
+        
+        # 设置元素内容
+        self.set_msg_list(obj_now["msg_list"])
+
+if __name__ == "__main__":
+    ser = """//line1
+//line2 
+//line3"""
+
+    obj = Comment()
+    obj.deserialize(ser)
+    print(obj.json_serialize())

link_rep-0.0.1/link_rep/LinkMethod.py

@@ -0,0 +1,82 @@
+from typing_extensions import override
+import json
+
+try:
+    from .LinkRepMetaObject import LinkRepMetaObject
+    from .LinkTerm import LinkTerm
+except:
+    from LinkRepMetaObject import LinkRepMetaObject
+    from LinkTerm import LinkTerm
+
+# component list 里面的元素是 LinkTerm
+class LinkMethod(LinkRepMetaObject):
+    def __init__(self) -> None:
+        super().__init__()
+        self.component_list = []
+
+    # 设置变量名的映射关系
+    def set_component_list(self, new_component_list:list[LinkTerm]) -> None:
+        self.component_list = new_component_list
+        for term in new_component_list:
+            if not isinstance(term, LinkTerm):
+                raise AssertionError()
+            
+    @override
+    def serialize(self) -> str:
+        return "".join(list(map(
+            lambda link_term: link_term.serialize(),
+            self.component_list
+        )))
+    
+    @override
+    def deserialize(self, s:str) -> None:
+        new_arr = []
+        for term in s.split("\n"):
+            if term.find("#") != -1:
+                link_term = LinkTerm()
+                link_term.deserialize(term.strip())
+                new_arr.append(link_term)
+        self.set_component_list(new_arr)
+
+    @override
+    def json_serialize(self) -> str:
+        return json.dumps({
+            "type": "LinkMethod",
+            "component_list": [
+                json.loads(link_term.json_serialize())
+                for link_term in self.component_list
+            ]
+        })
+    
+    @override
+    def json_deserialize(self, s:str) -> None:
+        obj_now = json.loads(s)
+
+        # 控制类型
+        if obj_now.get("type") != "LinkMethod":
+            raise AssertionError()
+        
+        # 必须包含完整信息
+        if not isinstance(obj_now.get("component_list"), list):
+            raise AssertionError()
+        
+        # 为了纯函数编程
+        def map_json_val_to_link_term(json_val:dict) -> LinkTerm:
+            link_term = LinkTerm()
+            link_term.json_deserialize(json.dumps(json_val))
+            return link_term
+
+        # 设置元素内容
+        self.set_component_list([
+            map_json_val_to_link_term(term)
+            for term in obj_now["component_list"]
+        ])
+
+if __name__ == "__main__":
+    var_def = LinkMethod()
+    var_def.deserialize("""\nL[1, 2]#L[2, 3]\nL[1, 3]#L[3, 3]\n""")
+
+    json_str = '{"type": "LinkMethod", "component_list": [{"type": "LinkTerm", "component_list": [[1, 2], [2, 3]]}, {"type": "LinkTerm", "component_list": [[1, 3], [3, 3]]}]}'
+    new_link = LinkMethod()
+    new_link.json_deserialize(json_str)
+    print(new_link.serialize())

link_rep-0.0.1/link_rep/LinkRep.py

@@ -0,0 +1,119 @@
+from typing_extensions import override
+import json
+
+try:
+    from .LinkRepMetaObject import LinkRepMetaObject
+    from .Comment import Comment
+    from .VarDef import VarDef
+    from .LinkSet import LinkSet
+    from .LinkMethod import LinkMethod
+except:
+    from LinkRepMetaObject import LinkRepMetaObject
+    from Comment import Comment
+    from VarDef import VarDef
+    from LinkSet import LinkSet
+    from LinkMethod import LinkMethod
+
+# 存储所有的变量定义
+class LinkRep(LinkRepMetaObject):
+    def __init__(self) -> None:
+        super().__init__()
+        self.comment = Comment()
+        self.var_def = VarDef()
+        self.link_set = LinkSet()
+        self.link_method = LinkMethod()
+
+    @override
+    def serialize(self) -> str:
+        return (
+            self.comment.serialize() +
+            self.var_def.serialize() +
+            self.link_set.serialize() +
+            self.link_method.serialize()
+        )
+    
+    @override
+    def deserialize(self, s:str) -> None:
+        s = s.strip()
+
+        comment_list = []
+        var_def_list = []
+        link_method_list = []
+        link_set_list = []
+        for line in s.split("\n"):
+            line = line.strip()
+            if line == "":
+                continue
+            if line.startswith("//"):
+                comment_list.append(line)
+            elif line.find(":") != -1:
+                var_def_list.append(line)
+            elif line.find("#") != -1:
+                link_method_list.append(line)
+            elif line.startswith("[") and line.endswith("]"):
+                link_set_list.append(line)
+            else:
+                raise AssertionError()
+        
+        if len(link_set_list) != 1:
+            raise AssertionError()
+
+        # 依次对所有元素进行反序列化
+        self.comment.deserialize("\n".join(comment_list))
+        self.var_def.deserialize("\n".join(var_def_list))
+        self.link_set.deserialize(link_set_list[0])
+        self.link_method.deserialize("\n".join(link_method_list))
+
+    @override
+    def json_serialize(self) -> str:
+        return json.dumps({
+            "type": "LinkRep",
+            "comment": json.loads(self.comment.json_serialize()),
+            "var_def": json.loads(self.var_def.json_serialize()),
+            "link_set": json.loads(self.link_set.json_serialize()),
+            "link_method": json.loads(self.link_method.json_serialize())
+        })
+    
+    @override
+    def json_deserialize(self, s:str) -> None:
+        obj_now = json.loads(s)
+
+        # 控制类型
+        if obj_now.get("type") != "LinkRep":
+            raise AssertionError()
+        
+        # 必须包含完整信息
+        for term_name in ["comment", "var_def", "link_set", "link_method"]:
+            if not isinstance(obj_now.get(term_name), dict):
+                raise AssertionError()
+
+            instance_now = self.__getattribute__(term_name)
+            if not isinstance(instance_now, LinkRepMetaObject):
+                raise AssertionError()
+            instance_now.json_deserialize(json.dumps(obj_now.get(term_name)))
+
+if __name__ == "__main__":
+    real_serial = (
+"""
+// this is comment line 1
+// this is comment line 2
+L2a1: [[4, 1, 3, 2], [2, 3, 1, 4]]
+L4a1: [[6, 1, 7, 2], [8, 3, 5, 4], [2, 5, 3, 6], [4, 7, 1, 8]]
+K3a1: [[1, 5, 2, 4], [3, 1, 4, 6], [5, 3, 6, 2]]
+[L2a1, L4a1, K3a1]
+L[1, 1]#L[2, 1]
+L[2, 2]#L[3, 1]
+""").lstrip()
+    
+    rev_obj = LinkRep()
+    rev_obj.deserialize(real_serial)
+    assert rev_obj.serialize() == real_serial
+
+    json_serialize = rev_obj.json_serialize()
+    rev_obj_2 = LinkRep()
+    rev_obj_2.json_deserialize(json_serialize)
+
+    assert rev_obj_2.serialize() == real_serial
+    assert rev_obj_2.json_serialize() == rev_obj.json_serialize()
+
+    print(rev_obj_2.serialize())

link_rep-0.0.1/link_rep/LinkRepMetaObject.py

@@ -0,0 +1,25 @@
+from abc import ABC, abstractmethod
+
+class LinkRepMetaObject(ABC):
+    def __init__(self) -> None:
+        pass
+    
+    # 标准字符串序列号化
+    @abstractmethod
+    def serialize(self) -> str:
+        return ""
+    
+    # 标准字符串反序列化
+    @abstractmethod
+    def deserialize(self, s:str) -> None:
+        return
+    
+    # JSON 字符串序列号化
+    @abstractmethod
+    def json_serialize(self) -> str:
+        return ""
+    
+    # JSON 字符串反序列化
+    @abstractmethod
+    def json_deserialize(self, s:str) -> None:
+        return

link_rep-0.0.1/link_rep/LinkSet.py

@@ -0,0 +1,68 @@
+from typing_extensions import override
+import json
+
+try:
+    from .LinkRepMetaObject import LinkRepMetaObject
+except:
+    from LinkRepMetaObject import LinkRepMetaObject
+
+# 存储所有的变量定义
+class LinkSet(LinkRepMetaObject):
+    def __init__(self) -> None:
+        super().__init__()
+        self.var_list = []
+
+    # 设置变量名的映射关系
+    def set_var_list(self, new_var_list:list[str]) -> None:
+        self.var_list = new_var_list
+
+    @override
+    def serialize(self) -> str:
+        return "[" + ", ".join(self.var_list) + "]\n"
+    
+    @override
+    def deserialize(self, s:str) -> None:
+        s = s.strip()
+
+        if not s.startswith("["):
+            raise AssertionError()
+        if not s.endswith("]"):
+            raise AssertionError()
+        
+        self.set_var_list([
+            item.strip()
+            for item in s[1:-1].split(",")
+        ])
+
+    @override
+    def json_serialize(self) -> str:
+        return json.dumps({
+            "type": "LinkSet",
+            "var_list": self.var_list
+        })
+    
+    @override
+    def json_deserialize(self, s:str) -> None:
+        obj_now = json.loads(s)
+
+        # 控制类型
+        if obj_now.get("type") != "LinkSet":
+            raise AssertionError()
+        
+        # 必须包含完整信息
+        if not isinstance(obj_now.get("var_list"), list):
+            raise AssertionError()
+        
+        # 设置元素内容
+        self.set_var_list(obj_now["var_list"])
+
+if __name__ == "__main__":
+    var_def = LinkSet()
+    var_def.set_var_list(["L2a1", "L4a1", "K3a1"])
+
+    ser = var_def.serialize()
+    print(ser)
+    
+    new_val = LinkSet()
+    new_val.json_deserialize('{"type": "LinkSet", "var_list": ["L2a1", "L4a1", "K3a1"]}')
+    print(new_val.json_serialize())

link_rep-0.0.1/link_rep/LinkTerm.py

@@ -0,0 +1,79 @@
+from typing_extensions import override
+import json
+
+try:
+    from .LinkRepMetaObject import LinkRepMetaObject
+except:
+    from LinkRepMetaObject import LinkRepMetaObject
+
+# 这个 component_list 里面放的东西是一个 list of list
+# 每个 sub_list 中有两个整数，L[i, j] 中的 i, j
+class LinkTerm(LinkRepMetaObject):
+    def __init__(self) -> None:
+        super().__init__()
+        self.component_list = []
+
+    # 设置变量名的映射关系
+    def set_component_list(self, new_component_list:list[list[int]]) -> None:
+        self.component_list = new_component_list
+        for term in new_component_list:
+            if not isinstance(term, list):
+                raise AssertionError()
+            if len(term) != 2:
+                raise AssertionError()
+            for sub_term in term:
+                if not isinstance(sub_term, int):
+                    raise AssertionError()
+            
+    @override
+    def serialize(self) -> str:
+        return "#".join(list(map(
+            lambda pr: f"L[{pr[0]}, {pr[1]}]", # 把连通分量编号
+            self.component_list
+        ))) + "\n"
+    
+    @override
+    def deserialize(self, s:str) -> None:
+        new_arr = []
+        for term in s.split("#"):
+            term = term.strip()
+            if term == "":
+                raise AssertionError()
+            if not (term.startswith("L[") and term.endswith("]")):
+                raise AssertionError()
+            li, ri = term[2:-1].split(",")
+            new_arr.append([int(li), int(ri)])
+        self.set_component_list(new_arr)
+
+    @override
+    def json_serialize(self) -> str:
+        return json.dumps({
+            "type": "LinkTerm",
+            "component_list": self.component_list
+        })
+    
+    @override
+    def json_deserialize(self, s:str) -> None:
+        obj_now = json.loads(s)
+
+        # 控制类型
+        if obj_now.get("type") != "LinkTerm":
+            raise AssertionError()
+        
+        # 必须包含完整信息
+        if not isinstance(obj_now.get("component_list"), list):
+            raise AssertionError()
+        
+        # 设置元素内容
+        self.set_component_list(obj_now["component_list"])
+
+if __name__ == "__main__":
+    var_def = LinkTerm()
+    var_def.set_component_list([[1, 1], [2, 1], [3, 2]])
+
+    ser = var_def.serialize()
+    print(ser)
+
+    new_var = LinkTerm()
+    new_var.deserialize("L[1, 1]#L[2, 1]#L[3, 2]")
+    print(new_var.json_serialize())

link_rep-0.0.1/link_rep/VarDef.py

@@ -0,0 +1,68 @@
+from typing_extensions import override
+import json
+
+try:
+    from .LinkRepMetaObject import LinkRepMetaObject
+except:
+    from LinkRepMetaObject import LinkRepMetaObject
+
+# 存储所有的变量定义
+class VarDef(LinkRepMetaObject):
+    def __init__(self) -> None:
+        super().__init__()
+        self.var_map = dict()
+
+    # 设置变量名的映射关系
+    def set_var_map(self, new_var_map:dict[str, list]) -> None:
+        self.var_map = new_var_map
+
+    @override
+    def serialize(self) -> str:
+        return "".join([
+            var_name + ": " + json.dumps(self.var_map[var_name]) + "\n"
+            for var_name in self.var_map
+        ])
+    
+    @override
+    def deserialize(self, s:str) -> None:
+        self.set_var_map({
+            item.split(":")[0].strip()
+                :json.loads(item.split(":")[-1])
+            for item in s.split("\n")
+            if item.find(":") != -1
+        })
+
+    @override
+    def json_serialize(self) -> str:
+        return json.dumps({
+            "type": "VarDef",
+            "var_map": self.var_map
+        })
+    
+    @override
+    def json_deserialize(self, s:str) -> None:
+        obj_now = json.loads(s)
+
+        # 控制类型
+        if obj_now.get("type") != "VarDef":
+            raise AssertionError()
+        
+        # 必须包含完整信息
+        if not isinstance(obj_now.get("var_map"), dict):
+            raise AssertionError()
+        
+        # 设置元素内容
+        self.set_var_map(obj_now["var_map"])
+
+if __name__ == "__main__":
+    var_def = VarDef()
+    var_def.set_var_map({
+        "L2a1": [[4, 1, 3, 2], [2, 3, 1, 4]],
+        "L4a1": [[6, 1, 7, 2], [8, 3, 5, 4], [2, 5, 3, 6], [4, 7, 1, 8]]
+    })
+
+    ser = """L2a1: [[4, 1, 3, 2], [2, 3, 1, 4]]
+L4a1: [[6, 1, 7, 2], [8, 3, 5, 4], [2, 5, 3, 6], [4, 7, 1, 8]]"""
+    
+    var_def.deserialize(ser)
+    print(var_def.json_serialize())

link_rep-0.0.1/link_rep/__init__.py

@@ -0,0 +1,15 @@
+from .Comment import Comment
+from .LinkMethod import LinkMethod
+from .LinkRep import LinkRep
+from .LinkSet import LinkSet
+from .LinkTerm import LinkTerm
+from .VarDef import VarDef
+
+__all__ = [
+    "Comment",
+    "LinkMethod",
+    "LinkRep", # 其中最重要的是 LinkRep
+    "LinkSet",
+    "LinkTerm",
+    "VarDef"
+]

link_rep-0.0.1/pyproject.toml

@@ -0,0 +1,18 @@
+[project]
+name = "link-rep"
+version = "0.0.1"
+description = "representation for a composite topological link."
+authors = [
+    {name = "GGN_2015",email = "premierbob@qq.com"}
+]
+license = {text = "MIT"}
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "typing_extensions"
+]
+
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"