lionagi 0.1.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

lionagi/tests/libs/test_nested.py

@@ -39,7 +39,7 @@ class TestNSet(unittest.TestCase):
         """Test flattening and then unflattening a nested dictionary."""
         original = {"a": {"b": {"c": 1}}}
         flattened = flatten(original)
-        self.assertEqual(flattened, {"a_b_c": 1})
+        self.assertEqual(flattened, {"a[^_^]b[^_^]c": 1})
         unflattened = unflatten(flattened)
         self.assertEqual(original, unflattened)
 
@@ -225,27 +225,36 @@ class TestFlatten(unittest.TestCase):
     def test_flatten_nested_dict(self):
         nested_dict = {"a": {"b": 1, "c": {"d": 2}}}
         result = flatten(nested_dict)
-        self.assertEqual(result, {"a_b": 1, "a_c_d": 2})
+        self.assertEqual(result, {"a[^_^]b": 1, "a[^_^]c[^_^]d": 2})
 
     def test_flatten_nested_list(self):
         nested_list = [[1, 2], [3, [4, 5]]]
         result = flatten(nested_list)
-        self.assertEqual(result, {"0_0": 1, "0_1": 2, "1_0": 3, "1_1_0": 4, "1_1_1": 5})
+        self.assertEqual(
+            result,
+            {
+                "0[^_^]0": 1,
+                "0[^_^]1": 2,
+                "1[^_^]0": 3,
+                "1[^_^]1[^_^]0": 4,
+                "1[^_^]1[^_^]1": 5,
+            },
+        )
 
     def test_flatten_with_max_depth(self):
         nested_dict = {"a": {"b": {"c": 1}}}
         result = flatten(nested_dict, max_depth=1)
-        self.assertEqual(result, {"a_b": {"c": 1}})
+        self.assertEqual(result, {"a[^_^]b": {"c": 1}})
 
     def test_flatten_dict_only(self):
         nested_mix = {"a": [1, 2], "b": {"c": 3}}
         result = flatten(nested_mix, dict_only=True)
-        self.assertEqual(result, {"a": [1, 2], "b_c": 3})
+        self.assertEqual(result, {"a": [1, 2], "b[^_^]c": 3})
 
     def test_flatten_inplace(self):
         nested_dict = {"a": {"b": 1}}
         flatten(nested_dict, inplace=True)
-        self.assertEqual(nested_dict, {"a_b": 1})
+        self.assertEqual(nested_dict, {"a[^_^]b": 1})
 
     def test_flatten_empty_structure(self):
         self.assertEqual(flatten({}), {})
@@ -254,18 +263,18 @@ class TestFlatten(unittest.TestCase):
     def test_flatten_deeply_nested_structure(self):
         deeply_nested = {"a": {"b": {"c": {"d": 1}}}}
         result = flatten(deeply_nested)
-        self.assertEqual(result, {"a_b_c_d": 1})
+        self.assertEqual(result, {"a[^_^]b[^_^]c[^_^]d": 1})
 
 
 class TestUnflatten(unittest.TestCase):
 
     def test_unflatten_to_nested_dict(self):
-        flat_dict = {"a_b": 1, "a_c_d": 2}
+        flat_dict = {"a[^_^]b": 1, "a[^_^]c[^_^]d": 2}
         result = unflatten(flat_dict)
         self.assertEqual(result, {"a": {"b": 1, "c": {"d": 2}}})
 
     def test_unflatten_to_nested_list(self):
-        flat_dict = {"0_0": 1, "0_1": 2, "1": [3, 4]}
+        flat_dict = {"0[^_^]0": 1, "0[^_^]1": 2, "1": [3, 4]}
         result = unflatten(flat_dict)
         self.assertEqual(result, [[1, 2], [3, 4]])
 
@@ -275,26 +284,26 @@ class TestUnflatten(unittest.TestCase):
         self.assertEqual(result, {"a": {"b": 1, "c": {"d": 2}}})
 
     def test_unflatten_with_custom_logic(self):
-        flat_dict = {"a_1": "one", "a_2": "two"}
+        flat_dict = {"a[^_^]1": "one", "a[^_^]2": "two"}
         custom_logic = lambda key: int(key) if key.isdigit() else key
         result = unflatten(flat_dict, custom_logic=custom_logic)
         self.assertEqual(result, {"a": [None, "one", "two"]})
 
     def test_unflatten_with_max_depth(self):
-        flat_dict = {"a_b_c": 1, "a_b_d": 2}
+        flat_dict = {"a[^_^]b[^_^]c": 1, "a[^_^]b[^_^]d": 2}
         result = unflatten(flat_dict, max_depth=1)
-        self.assertEqual(result, {"a": {"b_c": 1, "b_d": 2}})
+        self.assertEqual(result, {"a": {"b[^_^]c": 1, "b[^_^]d": 2}})
 
     def test_unflatten_with_max_depth_int(self):
-        flat_dict = {"0_0_0": 1, "0_1_0": 2}
+        flat_dict = {"0[^_^]0[^_^]0": 1, "0[^_^]1[^_^]0": 2}
         result = unflatten(flat_dict, max_depth=1)
-        self.assertEqual(result, [[{"0_0": 1}, {"1_0": 2}]])
+        self.assertEqual(result, [[{"0[^_^]0": 1}, {"1[^_^]0": 2}]])
 
     def test_unflatten_empty_flat_dict(self):
         self.assertEqual(unflatten({}), [])
 
     def test_unflatten_to_mixed_structure(self):
-        flat_dict = {"0_0": 1, "1_key": 2}
+        flat_dict = {"0[^_^]0": 1, "1[^_^]key": 2}
         result = unflatten(flat_dict)
         self.assertEqual(result, [[1], {"key": 2}])
 
@@ -319,7 +328,7 @@ class TestNInsert(unittest.TestCase):
     def test_insert_with_max_depth(self):
         obj = {}
         ninsert(obj, ["a", "b", "c"], "value", max_depth=1)
-        self.assertEqual(obj, {"a": {"b_c": "value"}})
+        self.assertEqual(obj, {"a": {"b[^_^]c": "value"}})
 
     def test_insert_into_empty_structure(self):
         obj = {}
@@ -331,24 +340,30 @@ class TestGetFlattenedKeys(unittest.TestCase):
 
     def test_get_keys_from_nested_dict(self):
         nested_dict = {"a": {"b": 1, "c": {"d": 2}}}
-        expected_keys = ["a_b", "a_c_d"]
+        expected_keys = ["a[^_^]b", "a[^_^]c[^_^]d"]
         self.assertEqual(set(get_flattened_keys(nested_dict)), set(expected_keys))
 
     def test_get_keys_from_nested_list(self):
         nested_list = [[1, 2], [3, [4, 5]]]
-        expected_keys = ["0_0", "0_1", "1_0", "1_1_0", "1_1_1"]
+        expected_keys = [
+            "0[^_^]0",
+            "0[^_^]1",
+            "1[^_^]0",
+            "1[^_^]1[^_^]0",
+            "1[^_^]1[^_^]1",
+        ]
         self.assertEqual(set(get_flattened_keys(nested_list)), set(expected_keys))
 
     def test_get_keys_with_max_depth(self):
         nested_dict = {"a": {"b": {"c": 1}}}
-        expected_keys = ["a_b"]
+        expected_keys = ["a[^_^]b"]
         self.assertEqual(
             set(get_flattened_keys(nested_dict, max_depth=1)), set(expected_keys)
         )
 
     def test_get_keys_dict_only(self):
         nested_mix = {"a": [1, 2], "b": {"c": 3}}
-        expected_keys = ["a", "b_c"]
+        expected_keys = ["a", "b[^_^]c"]
         self.assertEqual(
             set(get_flattened_keys(nested_mix, dict_only=True)), set(expected_keys)
         )
@@ -358,7 +373,7 @@ class TestGetFlattenedKeys(unittest.TestCase):
 
     def test_keys_from_deeply_nested_structure(self):
         deeply_nested = {"a": {"b": {"c": {"d": 1}}}}
-        expected_keys = ["a_b_c_d"]
+        expected_keys = ["a[^_^]b[^_^]c[^_^]d"]
         self.assertEqual(set(get_flattened_keys(deeply_nested)), set(expected_keys))
 
 

lionagi/tests/libs/test_parse.py

@@ -55,7 +55,7 @@ class TestFuzzyParseJson(unittest.TestCase):
     def test_extract_code_block(self):
         """Test extracting and parsing code blocks from Markdown."""
         markdown = '```python\nprint("Hello, world!")\n```'
-        result = ParseUtil.extract_code_block(
+        result = ParseUtil.extract_json_block(
             markdown, language="python", parser=lambda x: x
         )
         self.assertEqual(result, 'print("Hello, world!")')

lionagi/tests/test_core/collections/test_component.py

@@ -0,0 +1,206 @@
+import unittest
+from lionagi.core.collections.abc.component import (
+    Component,
+    LionValueError,
+    LionTypeError,
+)
+import pandas as pd
+from datetime import datetime
+import json
+
+
+class TestComponent(unittest.TestCase):
+
+    def setUp(self):
+        """Set up a basic Component instance for testing."""
+        self.component = Component()
+
+    def test_initialization(self):
+        """Test basic initialization and attributes."""
+        self.assertIsInstance(self.component.ln_id, str)
+        self.assertIsInstance(self.component.timestamp, str)
+        self.assertIsInstance(self.component.metadata, dict)
+        self.assertIsNone(self.component.content)
+        self.assertEqual(self.component.embedding, [])
+
+    def test_setting_attributes(self):
+        """Test setting and updating attributes."""
+        self.component.content = 1
+        self.assertEqual(self.component.content, 1)
+        self.assertIn("content", self.component.metadata["last_updated"])
+
+    def test_class_name(self):
+        """Test the class_name property."""
+        self.assertEqual(self.component.class_name, "Component")
+
+    def test_to_dict(self):
+        """Test converting to dictionary."""
+        self.component.content = "example content"
+        dict_repr = self.component.to_dict()
+        self.assertEqual(dict_repr["content"], "example content")
+        self.assertEqual(dict_repr["lion_class"], "Component")
+
+    def test_to_json_str(self):
+        """Test converting to JSON string."""
+        self.component.content = "example content"
+        json_str = self.component.to_json_str()
+        self.assertIn('"content": "example content"', json_str)
+
+    def test_to_xml(self):
+        """Test converting to XML string."""
+        self.component.content = "example content"
+        xml_str = self.component.to_xml()
+        self.assertIn("<content>example content</content>", xml_str)
+
+    def test_to_pd_series(self):
+        """Test converting to Pandas Series."""
+        self.component.content = "example content"
+        series = self.component.to_pd_series()
+        self.assertEqual(series["content"], "example content")
+
+    def test_from_obj_dict(self):
+        """Test creating a Component from a dictionary."""
+        dict_obj = {"a": 1, "b": 2}
+        new_component = Component.from_obj(dict_obj)
+        self.assertEqual(new_component.metadata["a"], 1)
+        self.assertEqual(new_component.metadata["b"], 2)
+
+    def test_from_obj_str(self):
+        """Test creating a Component from a JSON string."""
+        json_str = '{"a": 1, "b": 2}'
+        new_component = Component.from_obj(json_str)
+        self.assertEqual(new_component.metadata["a"], 1)
+        self.assertEqual(new_component.metadata["b"], 2)
+
+    def test_from_obj_fuzzy_str(self):
+        """Test creating a Component from a fuzzy JSON string."""
+        fuzzy_json_str = '{"name": "John", "age": 30, "city": ["New York", "DC", "LA"]'
+        new_component = Component.from_obj(fuzzy_json_str, fuzzy_parse=True)
+        self.assertEqual(new_component.metadata["name"], "John")
+        self.assertEqual(new_component.metadata["age"], 30)
+        self.assertEqual(new_component.metadata["city"], ["New York", "DC", "LA"])
+
+    def test_from_obj_series(self):
+        """Test creating a Component from a Pandas Series."""
+        series_obj = pd.Series({"a": 1, "b": 2})
+        new_component = Component.from_obj(series_obj)
+        self.assertEqual(new_component.metadata["a"], 1)
+        self.assertEqual(new_component.metadata["b"], 2)
+
+    def test_from_obj_dataframe(self):
+        """Test creating Components from a Pandas DataFrame."""
+        df = pd.DataFrame({"a": [1, 2], "b": [3, 4]}, index=["row1", "row2"])
+        components = Component.from_obj(df)
+        self.assertEqual(len(components), 2)
+        self.assertEqual(components[0].metadata["a"], 1)
+        self.assertEqual(components[0].metadata["b"], 3)
+        self.assertEqual(components[1].metadata["a"], 2)
+        self.assertEqual(components[1].metadata["b"], 4)
+
+    def test_metadata_manipulation(self):
+        """Test manipulation of metadata."""
+        self.component._meta_insert(["new_key"], "new_value")
+        self.assertEqual(self.component.metadata["new_key"], "new_value")
+        self.component._meta_set(["new_key"], "updated_value")
+        self.assertEqual(self.component.metadata["new_key"], "updated_value")
+        nested_value = {"a": 1, "b": 2}
+        self.component._meta_insert(["nested", 0], nested_value)
+        self.assertEqual(self.component.metadata["nested"][0], nested_value)
+        self.assertEqual(self.component._meta_get(["nested", 0, "a"]), 1)
+
+    def test_invalid_metadata_assignment(self):
+        """Test invalid direct assignment to metadata."""
+        with self.assertRaises(AttributeError):
+            self.component.metadata = {}
+
+    def test_field_annotations(self):
+        """Test field annotations."""
+        annotations = self.component._field_annotations
+        self.assertIn("ln_id", annotations)
+        self.assertIn("timestamp", annotations)
+
+    def test_dynamic_field_addition(self):
+        """Test adding fields dynamically to the Component."""
+        self.component._add_field(
+            "welcome", str, default="new value", value="hello world again"
+        )
+        self.assertEqual(
+            self.component._get_field_attr("welcome", "default"), "new value"
+        )
+        self.assertEqual(getattr(self.component, "welcome"), "hello world again")
+
+    def test_validation_error_handling(self):
+        """Test handling of validation errors."""
+        with self.assertRaises(LionValueError):
+            Component.from_obj({"ln_id": 12345})  # Invalid ln_id type
+
+    def test_str_repr_methods(self):
+        """Test __str__ and __repr__ methods."""
+        self.component.content = "example content"
+        self.assertIn("example content", str(self.component))
+        self.assertIn("example content", repr(self.component))
+
+    def test_embedded_content(self):
+        """Test embedded content handling."""
+        embedding_str = "[1.0, 2.0, 3.0]"
+        self.component.embedding = self.component._validate_embedding(embedding_str)
+        self.assertEqual(self.component.embedding, [1.0, 2.0, 3.0])
+
+    def test_invalid_embedded_content(self):
+        """Test invalid embedded content handling."""
+        with self.assertRaises(ValueError):
+            self.component._validate_embedding("[1.0, 'invalid', 3.0]")
+
+    def test_timestamp_format(self):
+        """Test if the timestamp is in the correct format."""
+        timestamp = self.component.timestamp
+        try:
+            datetime.strptime(timestamp, "%Y-%m-%dT%H:%M:%S.%f")
+        except ValueError:
+            self.fail("Timestamp is not in the correct format")
+
+    def test_default_field_values(self):
+        """Test the default values of fields."""
+        default_fields = self.component._all_fields
+        self.assertEqual(default_fields["embedding"].default, [])
+        self.assertEqual(default_fields["metadata"].default_factory(), {})
+        self.assertEqual(default_fields["extra_fields"].default_factory(), {})
+        self.assertIsNone(default_fields["content"].default)
+
+    def test_deeply_nested_metadata(self):
+        """Test setting and getting deeply nested metadata."""
+        nested_value = {"level1": {"level2": {"level3": "deep_value"}}}
+        self.component._meta_insert(["nested", 0], nested_value)
+        self.assertEqual(
+            self.component._meta_get(["nested", 0, "level1", "level2", "level3"]),
+            "deep_value",
+        )
+
+    def test_invalid_from_obj_type(self):
+        """Test invalid type in from_obj method."""
+        with self.assertRaises(LionTypeError):
+            Component.from_obj(12345)  # Invalid type
+
+    def test_from_obj_pydantic_model(self):
+        """Test creating a Component from a Pydantic BaseModel."""
+        from pydantic import BaseModel
+
+        class SampleModel(BaseModel):
+            name: str
+            age: int
+
+        sample_instance = SampleModel(name="John Doe", age=30)
+        new_component = Component.from_obj(sample_instance)
+        self.assertEqual(new_component.metadata["name"], "John Doe")
+        self.assertEqual(new_component.metadata["age"], 30)
+
+    def test_json_serialization_deserialization(self):
+        """Test JSON serialization and deserialization."""
+        original_dict = self.component.to_dict()
+        json_str = json.dumps(original_dict)
+        new_component = Component.from_obj(json_str)
+        self.assertEqual(original_dict, new_component.to_dict())
+
+
+if __name__ == "__main__":
+    unittest.main()

lionagi/tests/test_core/collections/test_exchange.py

@@ -0,0 +1,138 @@
+import unittest
+from lionagi import Node, pile, progression
+from lionagi.core.collections.abc import Element
+from lionagi.core.collections import Exchange
+
+
+class TestExchange(unittest.TestCase):
+
+    def setUp(self):
+        # Setup for creating initial nodes, piles, and progressions
+        self.nodes = [Node(content=i) for i in range(10)]
+        self.pile1 = pile(self.nodes)
+        self.prog1 = progression(self.nodes[:5], name="left")
+        self.prog2 = progression(self.nodes[5:], name="right")
+        self.exchange = Exchange()
+
+    def test_initialization(self):
+        self.assertEqual(len(self.exchange.pile), 0)
+        self.assertEqual(len(self.exchange.pending_ins), 0)
+        self.assertEqual(len(self.exchange.pending_outs), 0)
+
+    def test_include_in(self):
+        sender_id = "sender1"
+        for node in self.nodes[:5]:
+            node.sender = sender_id
+            self.exchange.include(node, "in")
+
+        self.assertEqual(len(self.exchange.pile), 5)
+        self.assertIn(sender_id, self.exchange.pending_ins)
+        self.assertEqual(len(self.exchange.pending_ins[sender_id]), 5)
+
+    def test_include_out(self):
+        for node in self.nodes[:5]:
+            self.exchange.include(node, "out")
+
+        self.assertEqual(len(self.exchange.pile), 5)
+        self.assertEqual(len(self.exchange.pending_outs), 5)
+
+    def test_exclude(self):
+        for node in self.nodes[:5]:
+            self.exchange.include(node, "out")
+
+        node_to_remove = self.nodes[0]
+        self.exchange.exclude(node_to_remove)
+        self.assertNotIn(node_to_remove, self.exchange.pile)
+        self.assertNotIn(node_to_remove, self.exchange.pending_outs)
+
+    def test_exclude_from_in(self):
+        sender_id = "sender1"
+        for node in self.nodes[:5]:
+            node.sender = sender_id
+            self.exchange.include(node, "in")
+
+        node_to_remove = self.nodes[0]
+        self.exchange.exclude(node_to_remove)
+        self.assertNotIn(node_to_remove, self.exchange.pile)
+        self.assertNotIn(node_to_remove, self.exchange.pending_ins[sender_id])
+
+    def test_senders(self):
+        sender_id = "sender1"
+        for node in self.nodes[:5]:
+            node.sender = sender_id
+            self.exchange.include(node, "in")
+
+        self.assertIn(sender_id, self.exchange.senders)
+
+    def test_to_dict(self):
+        for node in self.nodes[:5]:
+            self.exchange.include(node, "out")
+
+        exchange_dict = self.exchange.to_dict()
+        self.assertIn("pile", exchange_dict)
+        self.assertIn("pending_ins", exchange_dict)
+        self.assertIn("pending_outs", exchange_dict)
+
+    def test_bool(self):
+        self.assertTrue(self.exchange)
+
+    # Additional Tests for Edge Cases
+    def test_include_non_sendable(self):
+        non_sendable = Element()
+        with self.assertRaises(AttributeError):
+            self.exchange.include(non_sendable, "in")
+
+    def test_exclude_nonexistent_item(self):
+        non_existent_node = Node(content="nonexistent")
+        result = self.exchange.exclude(non_existent_node)
+        self.assertTrue(result)
+
+    def test_include_multiple_items_in(self):
+        sender_id = "sender2"
+        new_nodes = [Node(content="new_node1"), Node(content="new_node2")]
+        for new_node in new_nodes:
+            new_node.sender = sender_id
+            self.exchange.include(new_node, "in")
+
+        self.assertEqual(len(self.exchange.pile), 2)
+        self.assertEqual(len(self.exchange.pending_ins[sender_id]), 2)
+
+    def test_include_multiple_items_out(self):
+        new_nodes = [Node(content="new_node1"), Node(content="new_node2")]
+        for new_node in new_nodes:
+            self.exchange.include(new_node, "out")
+
+        self.assertEqual(len(self.exchange.pile), 2)
+        self.assertEqual(len(self.exchange.pending_outs), 2)
+
+    def test_exclude_from_empty_exchange(self):
+        result = self.exchange.exclude(Node(content="nonexistent"))
+        self.assertTrue(result)
+
+    def test_clear_empty_exchange(self):
+        self.exchange.pile.clear()
+        self.exchange.pending_ins.clear()
+        self.exchange.pending_outs.clear()
+        self.assertEqual(len(self.exchange.pile), 0)
+        self.assertEqual(len(self.exchange.pending_ins), 0)
+        self.assertEqual(len(self.exchange.pending_outs), 0)
+
+    def test_clear_exchange(self):
+        sender_id = "sender3"
+        for node in self.nodes[:5]:
+            node.sender = sender_id
+            self.exchange.include(node, "in")
+        for node in self.nodes[5:]:
+            self.exchange.include(node, "out")
+
+        self.exchange.pile.clear()
+        self.exchange.pending_ins.clear()
+        self.exchange.pending_outs.clear()
+
+        self.assertEqual(len(self.exchange.pile), 0)
+        self.assertEqual(len(self.exchange.pending_ins), 0)
+        self.assertEqual(len(self.exchange.pending_outs), 0)
+
+
+if __name__ == "__main__":
+    unittest.main()

lionagi/tests/test_core/collections/test_flow.py

@@ -0,0 +1,145 @@
+import unittest
+from lionagi import Node, pile, progression, flow
+
+
+class TestFlow(unittest.TestCase):
+
+    def setUp(self):
+        # Setup for creating initial nodes, piles, and progressions
+        self.nodes = [Node(content=i) for i in range(10)]
+        self.pile1 = pile(self.nodes)
+        self.prog1 = progression(self.nodes[:5], name="left")
+        self.prog2 = progression(self.nodes[5:], name="right")
+        self.flow = flow([self.prog1, self.prog2])
+
+    def test_initialization(self):
+        self.assertEqual(len(self.flow.sequences), 2)
+        self.assertIn("left", self.flow.registry)
+        self.assertIn("right", self.flow.registry)
+
+    def test_append_to_flow(self):
+        new_node = Node(content="new_node")
+        self.flow.append(new_node, "left")
+        self.assertIn(new_node.ln_id, self.flow.get("left"))
+
+    def test_exclude_from_flow(self):
+        node_to_remove = self.nodes[0]
+        self.flow.exclude("left", node_to_remove)
+        self.assertNotIn(node_to_remove.ln_id, self.flow.get("left"))
+
+    def test_get_sequence(self):
+        seq = self.flow.get("left")
+        self.assertEqual(seq, self.prog1)
+        seq_default = self.flow.get("nonexistent", default=None)
+        self.assertIsNone(seq_default)
+
+    def test_register_sequence(self):
+        new_prog = progression(self.nodes[2:4], name="middle")
+        self.flow.register(new_prog)
+        self.assertIn("middle", self.flow.registry)
+
+    def test_popleft(self):
+        first_node_id = self.prog1[0]
+        removed_node_id = self.flow.popleft("left")
+        self.assertEqual(first_node_id, removed_node_id)
+        self.assertNotIn(removed_node_id, self.flow.get("left"))
+
+    def test_shape_and_size(self):
+        shape = self.flow.shape()
+        self.assertEqual(shape["left"], 5)
+        self.assertEqual(shape["right"], 5)
+        size = self.flow.size()
+        self.assertEqual(size, 10)
+
+    def test_clear(self):
+        self.flow.clear()
+        self.assertEqual(len(self.flow.sequences), 0)
+        self.assertEqual(len(self.flow.registry), 0)
+
+    def test_iteration(self):
+        items = list(self.flow)
+        self.assertEqual(len(items), 2)
+
+    def test_to_df(self):
+        df = self.flow.to_df()
+        self.assertEqual(df.shape[0], 2)
+        self.assertEqual(df.columns.tolist(), ["order", "name"])
+
+    def test_inclusion_check(self):
+        self.assertTrue(self.prog1 in self.flow)
+        self.assertTrue(self.prog2 in self.flow)
+        try:
+            a = Node(content="nonexistent") in self.flow
+        except TypeError:
+            pass
+
+    # Additional Tests for Edge Cases
+    def test_empty_flow_initialization(self):
+        empty_flow = flow()
+        self.assertEqual(len(empty_flow.sequences), 0)
+        self.assertEqual(len(empty_flow.registry), 0)
+
+    def test_append_to_nonexistent_sequence(self):
+        new_node = Node(content="new_node")
+        self.flow.append(new_node, "nonexistent")
+        self.assertIn(new_node.ln_id, self.flow.get("nonexistent"))
+
+    def test_exclude_nonexistent_item(self):
+        non_existent_node = Node(content="nonexistent")
+        result = self.flow.exclude("left", non_existent_node)
+        self.assertTrue(result)
+
+    def test_exclude_nonexistent_sequence(self):
+        result = self.flow.exclude("nonexistent")
+        self.assertFalse(result)
+
+    def test_get_nonexistent_sequence(self):
+        try:
+            self.flow.get("nonexistent")
+        except Exception as e:
+            if e.__class__.__name__ == "LionTypeError":
+                return
+            raise AssertionError("LionTypeError not raised")
+
+    def test_register_existing_sequence_name(self):
+        with self.assertRaises(ValueError):
+            self.flow.register(self.prog1, name="right")
+
+    def test_popleft_nonexistent_sequence(self):
+        try:
+            self.flow.popleft("nonexistent")
+        except Exception as e:
+            if e.__class__.__name__ == "LionTypeError":
+                return
+            raise AssertionError("LionTypeError not raised")
+
+    def test_append_multiple_items(self):
+        new_nodes = [Node(content="new_node1"), Node(content="new_node2")]
+        for new_node in new_nodes:
+            self.flow.append(new_node, "left")
+        for new_node in new_nodes:
+            self.assertIn(new_node.ln_id, self.flow.get("left"))
+
+    def test_remove_from_all_sequences(self):
+        node_to_remove = self.nodes[0]
+        self.flow.append(node_to_remove, "right")
+        self.flow.remove(node_to_remove)
+        self.assertNotIn(node_to_remove.ln_id, self.flow.get("right"))
+
+    def test_shape_empty_flow(self):
+        empty_flow = flow()
+        self.assertEqual(empty_flow.shape(), {})
+
+    def test_size_empty_flow(self):
+        empty_flow = flow()
+        self.assertEqual(empty_flow.size(), 0)
+
+    def test_clear_empty_flow(self):
+        empty_flow = flow()
+        empty_flow.clear()
+        self.assertEqual(len(empty_flow.sequences), 0)
+        self.assertEqual(len(empty_flow.registry), 0)
+
+
+if __name__ == "__main__":
+    unittest.main()