Download MemSkill/src/executor.py from SitongGong/gst-code-collection: direct link, hf CLI and curl.
- Browser
- Download file 26.2 kB
-
https://huggingface.co/datasets/SitongGong/gst-code-collection/resolve/main/MemSkill/src/executor.py
- Command line
-
hf download hf://datasets/SitongGong/gst-code-collection/MemSkill/src/executor.py
-
curl -L -o executor.py https://huggingface.co/datasets/SitongGong/gst-code-collection/resolve/main/MemSkill/src/executor.py
26.2 kB
| """ | |
| Executor: Executes operations using LLM API | |
| """ | |
| import json | |
| import re | |
| import logging | |
| import sys | |
| import os | |
| sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) | |
| from json_repair import repair_json | |
| from llm_utils import get_llm_response_via_api | |
| from rag_utils import get_embeddings | |
| from typing import List, Union | |
| class ExecutionResult: | |
| """Result of operation execution""" | |
| def __init__(self, action_type: str, success: bool, | |
| memory_index: int = -1, memory_content: str = "", | |
| reasoning: str = ""): | |
| self.action_type = action_type # INSERT, UPDATE, DELETE, NOOP | |
| self.success = success | |
| self.memory_index = memory_index | |
| self.memory_content = memory_content | |
| self.reasoning = reasoning | |
| def __repr__(self): | |
| return f"ExecutionResult(action={self.action_type}, success={self.success}, " \ | |
| f"mem_idx={self.memory_index}, reasoning={self.reasoning[:100]}...)" | |
| class Executor: | |
| """ | |
| Executor executes operations by calling LLM API | |
| Parses LLM output and applies changes to memory bank | |
| """ | |
| def __init__(self, args): | |
| self.args = args | |
| self.retriever_name = args.retriever | |
| self.logger = logging.getLogger('AgenticMemory') | |
| def _build_executor_prompt(self, operations: List, session_text: str, | |
| retrieved_memories: List[str]) -> str: | |
| """Build the executor prompt from selected memory management skills.""" | |
| if len(retrieved_memories) > 0: | |
| mem_text = "\n".join([f"{i}. {mem}" for i, mem in enumerate(retrieved_memories)]) | |
| else: | |
| mem_text = "(No existing memories retrieved)" | |
| skill_blocks = [] | |
| seen = set() | |
| for op in operations: | |
| name = getattr(op, "name", None) | |
| if not name: | |
| continue | |
| if name in seen: | |
| continue | |
| seen.add(name) | |
| description = str(getattr(op, "description", "")).strip() | |
| instructions = str(getattr(op, "instruction_template", "")).strip() | |
| update_type = str(getattr(op, "update_type", "")).strip().upper() | |
| lines = [f"[Skill {len(seen)}] {name}"] | |
| if description: | |
| lines.append(f"Description: {description}") | |
| if update_type: | |
| lines.append(f"Allowed action: {update_type}") | |
| if instructions: | |
| lines.append("Instructions:") | |
| lines.append(instructions) | |
| skill_blocks.append("\n".join(lines)) | |
| skills_text = "\n\n".join(skill_blocks) if skill_blocks else "(No skills provided)" | |
| return ( | |
| "You are a memory management executor. Apply the selected skills to the input text\n" | |
| "chunk and retrieved memories, then output memory actions.\n\n" | |
| "Input Text Chunk:\n" | |
| f"{session_text}\n\n" | |
| "Retrieved Memories (0-based index):\n" | |
| f"{mem_text}\n\n" | |
| "Selected Skills:\n" | |
| f"{skills_text}\n\n" | |
| "Guidelines:\n" | |
| "- Apply any skill as needed; a skill may be used multiple times.\n" | |
| "- Read the input text chunk carefully line by line and apply any skill as needed.\n" | |
| "- Only use action types supported by the selected skills.\n" | |
| "- MEMORY_INDEX is 0-based and must reference the retrieved memories list.\n" | |
| "- Output only action blocks in the format below.\n" | |
| "- Do not include explanations or REASONING lines.\n" | |
| "Output format (repeat as needed). Use ONE block per action and separate blocks with" | |
| " a blank line:\n\n" | |
| "INSERT block:\n" | |
| "ACTION: INSERT\n" | |
| "MEMORY_ITEM: <concise but complete summary with essential details>\n\n" | |
| "UPDATE block:\n" | |
| "ACTION: UPDATE\n" | |
| "MEMORY_INDEX: <0-based index>\n" | |
| "UPDATED_MEMORY: <concise but complete merged summary with essential updates>\n\n" | |
| "DELETE block:\n" | |
| "ACTION: DELETE\n" | |
| "MEMORY_INDEX: <0-based index>\n\n" | |
| ) | |
| def execute_operation(self, operation: Union[object, List[object]], session_text: str, | |
| retrieved_memories: List[str]) -> List[ExecutionResult]: | |
| """ | |
| Execute a memory operation | |
| Args: | |
| operation: Operation object or list of Operation objects (skills) | |
| session_text: current session text | |
| retrieved_memories: list of retrieved memory contents | |
| Returns: | |
| List[ExecutionResult]: list of execution results (LLM may return multiple actions) | |
| """ | |
| if isinstance(operation, (list, tuple)): | |
| operations = list(operation) | |
| else: | |
| operations = [operation] | |
| operations = [op for op in operations if op is not None] | |
| if len(operations) == 0: | |
| return [ExecutionResult( | |
| action_type="NOOP", | |
| success=False, | |
| reasoning="No operations provided" | |
| )] | |
| sub_chunks = [session_text] | |
| all_results = [] | |
| for sub_text in sub_chunks: | |
| if not sub_text.strip(): | |
| continue | |
| # Build executor prompt from selected skills | |
| instruction = self._build_executor_prompt(operations, sub_text, retrieved_memories) | |
| # Call LLM API | |
| try: | |
| response, _, _ = get_llm_response_via_api( | |
| prompt=instruction, | |
| LLM_MODEL=self.args.model, | |
| base_url=self.args.api_base, | |
| api_key=self.args.api_key, | |
| MAX_TOKENS=self.args.max_new_tokens, | |
| TAU=self.args.temperature, | |
| MAX_TRIALS=10, | |
| TIME_GAP=3, | |
| ) | |
| except Exception as e: | |
| self.logger.warning(f"Executor API call failed: {e}") | |
| all_results.append(ExecutionResult( | |
| action_type="NOOP", | |
| success=False, | |
| reasoning=f"API call failed: {str(e)}" | |
| )) | |
| continue | |
| # Parse response (may contain multiple actions) | |
| all_results.extend(self._parse_response(response, len(retrieved_memories))) | |
| if not all_results: | |
| return [ExecutionResult( | |
| action_type="NOOP", | |
| success=False, | |
| reasoning="No executor results produced" | |
| )] | |
| return all_results | |
| def _parse_response(self, response: str, num_retrieved: int) -> List[ExecutionResult]: | |
| """ | |
| Parse LLM response to extract actions and content. | |
| Supports multiple action blocks in a single response. | |
| Expected format (can repeat multiple times): | |
| ACTION: INSERT/UPDATE/DELETE/NOOP | |
| or line-only action marker: | |
| INSERT/UPDATE/DELETE/NOOP | |
| [MEMORY_INDEX: <index>] # for UPDATE/DELETE | |
| [MEMORY_ITEM/UPDATED_MEMORY: <content>] # for INSERT/UPDATE | |
| REASONING: <reasoning> | |
| Returns: | |
| List[ExecutionResult]: list of parsed results | |
| """ | |
| response = self._normalize_response(response) | |
| results = [] | |
| # Split response into individual action blocks. | |
| # Primary format: "ACTION: INSERT/UPDATE/DELETE/NOOP" | |
| action_pattern = re.compile( | |
| r'(?<!\w)ACTION\s*(?::|=|-)?\s*(INSERT|UPDATE|DELETE|NOOP)\b', | |
| re.IGNORECASE | |
| ) | |
| action_matches = list(action_pattern.finditer(response)) | |
| # Compatibility format (no ACTION prefix): | |
| # INSERT | |
| # MEMORY_ITEM: ... | |
| if not action_matches: | |
| line_action_pattern = re.compile( | |
| r'(?im)^(?:[-*]\s*)?(INSERT|UPDATE|DELETE|NOOP)\s*(?::|=|-)?\s*$' | |
| ) | |
| action_matches = list(line_action_pattern.finditer(response)) | |
| if not action_matches: | |
| json_results = self._parse_json_response(response, num_retrieved) | |
| if json_results: | |
| return json_results | |
| self.logger.warning("ACTION: INSERT/UPDATE/DELETE/NOOP PARSE FAILED") | |
| print(response) | |
| return [ExecutionResult( | |
| action_type="NOOP", | |
| success=False, | |
| reasoning="Failed to parse ACTION from response" | |
| )] | |
| # Parse each action block | |
| for i, match in enumerate(action_matches): | |
| # Determine the block boundaries | |
| block_start = match.start() | |
| block_end = action_matches[i + 1].start() if i + 1 < len(action_matches) else len(response) | |
| block = response[block_start:block_end].strip() | |
| result = self._parse_single_action(block, num_retrieved) | |
| if isinstance(result, list): | |
| results.extend(result) | |
| else: | |
| results.append(result) | |
| return results | |
| def _normalize_response(self, response: str) -> str: | |
| text = response.replace("\r\n", "\n").strip() | |
| if text.startswith("```"): | |
| parts = text.split("```") | |
| if len(parts) >= 3: | |
| text = parts[1] | |
| if "\n" in text: | |
| first_line, rest = text.split("\n", 1) | |
| if first_line.strip().lower() in ("json", "text"): | |
| text = rest | |
| return text.strip() | |
| def _parse_json_response(self, response: str, num_retrieved: int) -> List[ExecutionResult]: | |
| json_start = response.find("{") | |
| json_end = response.rfind("}") + 1 | |
| if json_start == -1 or json_end == 0: | |
| return [] | |
| try: | |
| json_str = response[json_start:json_end] | |
| repaired_json = repair_json(json_str) | |
| data = json.loads(repaired_json) | |
| except Exception: | |
| return [] | |
| items = [] | |
| if isinstance(data, dict): | |
| if isinstance(data.get("actions"), list): | |
| items = data["actions"] | |
| else: | |
| items = [data] | |
| elif isinstance(data, list): | |
| items = data | |
| else: | |
| return [] | |
| results = [] | |
| for item in items: | |
| if not isinstance(item, dict): | |
| continue | |
| action = str(item.get("action", item.get("ACTION", ""))).strip().upper() | |
| if action == "INSERT": | |
| content = str(item.get("memory_item", item.get("MEMORY_ITEM", ""))).strip() | |
| if not content: | |
| continue | |
| results.append(ExecutionResult( | |
| action_type="INSERT", | |
| success=True, | |
| memory_content=content, | |
| reasoning=str(item.get("reasoning", "")).strip() or "No reasoning provided" | |
| )) | |
| elif action == "UPDATE": | |
| idx = item.get("memory_index", item.get("MEMORY_INDEX", None)) | |
| content = str(item.get("updated_memory", item.get("UPDATED_MEMORY", ""))).strip() | |
| if idx is None or content == "": | |
| continue | |
| try: | |
| idx = int(idx) | |
| except Exception: | |
| continue | |
| if idx < 0 or idx >= num_retrieved: | |
| continue | |
| results.append(ExecutionResult( | |
| action_type="UPDATE", | |
| success=True, | |
| memory_index=idx, | |
| memory_content=content, | |
| reasoning=str(item.get("reasoning", "")).strip() or "No reasoning provided" | |
| )) | |
| elif action == "DELETE": | |
| idx = item.get("memory_index", item.get("MEMORY_INDEX", None)) | |
| if idx is None: | |
| continue | |
| try: | |
| idx = int(idx) | |
| except Exception: | |
| continue | |
| if idx < 0 or idx >= num_retrieved: | |
| continue | |
| results.append(ExecutionResult( | |
| action_type="DELETE", | |
| success=True, | |
| memory_index=idx, | |
| reasoning=str(item.get("reasoning", "")).strip() or "No reasoning provided" | |
| )) | |
| elif action == "NOOP": | |
| results.append(ExecutionResult( | |
| action_type="NOOP", | |
| success=True, | |
| reasoning=str(item.get("reasoning", "")).strip() or "No reasoning provided" | |
| )) | |
| return results | |
| def _parse_single_action(self, block: str, num_retrieved: int) -> ExecutionResult: | |
| """ | |
| Parse a single action block. | |
| Args: | |
| block: text containing one ACTION block | |
| num_retrieved: number of retrieved memories (for index validation) | |
| Returns: | |
| ExecutionResult | |
| """ | |
| # Extract ACTION (preferred explicit format) | |
| action_match = re.search( | |
| r'ACTION\s*(?::|=|-)?\s*(INSERT|UPDATE|DELETE|NOOP)\b', | |
| block, | |
| re.IGNORECASE | |
| ) | |
| # Backward-compatible fallback: line-only action marker. | |
| if not action_match: | |
| action_match = re.search( | |
| r'(?im)^(?:[-*]\s*)?(INSERT|UPDATE|DELETE|NOOP)\s*(?::|=|-)?\s*$', | |
| block | |
| ) | |
| if not action_match: | |
| return ExecutionResult( | |
| action_type="NOOP", | |
| success=False, | |
| reasoning="Failed to parse ACTION from block" | |
| ) | |
| action_type = action_match.group(1).upper() | |
| # Extract REASONING | |
| reasoning_match = re.search( | |
| r'REASONING\s*(?::|=|-)?\s*(.+?)(?=[\s,;]*(?:ACTION\s*(?::|=|-)?|MEMORY[_ ]ITEM\s*(?::|=|-)?|' | |
| r'UPDATED[_ ]MEMORY\s*(?::|=|-)?|MEMORY[_ ]INDEX\s*(?::|=|-)?|$))', | |
| block, | |
| re.IGNORECASE | re.DOTALL | |
| ) | |
| reasoning = reasoning_match.group(1).strip() if reasoning_match else "No reasoning provided" | |
| # Parse based on action type | |
| if action_type == "NOOP": | |
| return ExecutionResult( | |
| action_type="NOOP", | |
| success=True, | |
| reasoning=reasoning | |
| ) | |
| elif action_type == "INSERT": | |
| memory_pattern = re.compile( | |
| r'(?:MEMORY[_ ]ITEM|NEW[_ ]MEMORY|CONTENT|MEMORY)\s*(?::|=|-)?\s*(.+?)(?=[\s,;]*' | |
| r'(?:REASONING\s*(?::|=|-)?|MEMORY[_ ]ITEM\s*(?::|=|-)?|UPDATED[_ ]MEMORY\s*(?::|=|-)?|' | |
| r'MEMORY[_ ]INDEX\s*(?::|=|-)?|ACTION\s*(?::|=|-)?|$))', | |
| re.IGNORECASE | re.DOTALL | |
| ) | |
| memory_matches = [m.strip() for m in memory_pattern.findall(block) if m.strip()] | |
| if not memory_matches: | |
| fallback_lines = [] | |
| for line in block.splitlines(): | |
| stripped = line.strip() | |
| if not stripped: | |
| continue | |
| if re.match(r'^(ACTION|MEMORY[_ ]ITEM|UPDATED[_ ]MEMORY|MEMORY[_ ]INDEX|REASONING)\b', stripped, re.IGNORECASE): | |
| continue | |
| if re.match(r'^\w+\s+block\s*:?\s*$', stripped, re.IGNORECASE): | |
| continue | |
| stripped = re.sub(r'^[-*•]\s*', '', stripped) | |
| stripped = re.sub(r'^\d+\.\s*', '', stripped) | |
| if stripped: | |
| fallback_lines.append(stripped) | |
| memory_matches = fallback_lines | |
| if not memory_matches: | |
| return ExecutionResult( | |
| action_type="NOOP", | |
| success=False, | |
| reasoning="Failed to parse MEMORY_ITEM for INSERT" | |
| ) | |
| if len(memory_matches) == 1: | |
| return ExecutionResult( | |
| action_type="INSERT", | |
| success=True, | |
| memory_content=memory_matches[0], | |
| reasoning=reasoning | |
| ) | |
| results = [] | |
| for mem in memory_matches: | |
| results.append(ExecutionResult( | |
| action_type="INSERT", | |
| success=True, | |
| memory_content=mem, | |
| reasoning=reasoning | |
| )) | |
| return results | |
| elif action_type == "UPDATE": | |
| index_matches = re.findall( | |
| r'MEMORY[_ ]INDEX\s*(?::|=|-)?\s*(\d+)', | |
| block, | |
| re.IGNORECASE | |
| ) | |
| update_pattern = re.compile( | |
| r'UPDATED[_ ]MEMORY\s*(?::|=|-)?\s*(.+?)(?=[\s,;]*(?:REASONING\s*(?::|=|-)?|' | |
| r'UPDATED[_ ]MEMORY\s*(?::|=|-)?|MEMORY[_ ]ITEM\s*(?::|=|-)?|' | |
| r'MEMORY[_ ]INDEX\s*(?::|=|-)?|ACTION\s*(?::|=|-)?|$))', | |
| re.IGNORECASE | re.DOTALL | |
| ) | |
| update_matches = [m.strip() for m in update_pattern.findall(block) if m.strip()] | |
| if not index_matches or not update_matches: | |
| return ExecutionResult( | |
| action_type="NOOP", | |
| success=False, | |
| reasoning="Failed to parse MEMORY_INDEX/UPDATED_MEMORY for UPDATE" | |
| ) | |
| pair_count = min(len(index_matches), len(update_matches)) | |
| results = [] | |
| for i in range(pair_count): | |
| memory_index = int(index_matches[i]) | |
| if memory_index >= num_retrieved: | |
| results.append(ExecutionResult( | |
| action_type="NOOP", | |
| success=False, | |
| reasoning=f"MEMORY_INDEX {memory_index} out of range [0, {num_retrieved})" | |
| )) | |
| continue | |
| results.append(ExecutionResult( | |
| action_type="UPDATE", | |
| success=True, | |
| memory_index=memory_index, | |
| memory_content=update_matches[i], | |
| reasoning=reasoning | |
| )) | |
| if len(results) == 1: | |
| return results[0] | |
| return results | |
| elif action_type == "DELETE": | |
| index_matches = re.findall( | |
| r'MEMORY[_ ]INDEX\s*(?::|=|-)?\s*(\d+)', | |
| block, | |
| re.IGNORECASE | |
| ) | |
| if not index_matches: | |
| return ExecutionResult( | |
| action_type="NOOP", | |
| success=False, | |
| reasoning="Failed to parse MEMORY_INDEX for DELETE" | |
| ) | |
| results = [] | |
| for idx_str in index_matches: | |
| memory_index = int(idx_str) | |
| if memory_index >= num_retrieved: | |
| results.append(ExecutionResult( | |
| action_type="NOOP", | |
| success=False, | |
| reasoning=f"MEMORY_INDEX {memory_index} out of range [0, {num_retrieved})" | |
| )) | |
| continue | |
| results.append(ExecutionResult( | |
| action_type="DELETE", | |
| success=True, | |
| memory_index=memory_index, | |
| reasoning=reasoning | |
| )) | |
| if len(results) == 1: | |
| return results[0] | |
| return results | |
| else: | |
| return ExecutionResult( | |
| action_type="NOOP", | |
| success=False, | |
| reasoning=f"Unknown action type: {action_type}" | |
| ) | |
| def apply_to_memory_bank(self, results: List[ExecutionResult], | |
| memory_bank, retrieved_indices: List[int], | |
| operation_name: Union[str, List[str], None] = None) -> bool: | |
| """ | |
| Apply execution results to memory bank. | |
| Handles multiple results from a single LLM response. | |
| Note: DELETE operations need special handling because indices shift | |
| after deletion. We process DELETEs in reverse order of index to avoid | |
| index invalidation issues. | |
| Optimization: Batch compute embeddings for all INSERT/UPDATE operations | |
| at once instead of one by one. | |
| Args: | |
| results: List[ExecutionResult] | |
| memory_bank: MemoryBank object | |
| retrieved_indices: indices of retrieved memories in memory bank | |
| operation_name: Operation name or list of names for history tracking | |
| Returns: | |
| success: bool (True if all operations succeeded) | |
| """ | |
| if not results: | |
| return True | |
| # Separate operations by type for proper ordering | |
| inserts = [r for r in results if r.action_type == "INSERT" and r.success] | |
| updates = [r for r in results if r.action_type == "UPDATE" and r.success] | |
| deletes = [r for r in results if r.action_type == "DELETE" and r.success] | |
| # print(len(inserts), len(updates), len(deletes)) | |
| all_success = True | |
| # Batch compute embeddings for UPDATE and INSERT operations | |
| # Collect all contents that need embeddings | |
| update_contents = [r.memory_content for r in updates] | |
| insert_contents = [r.memory_content for r in inserts] | |
| all_contents = update_contents + insert_contents | |
| # Batch compute retriever embeddings | |
| all_retriever_embeddings = [] | |
| if all_contents: | |
| try: | |
| all_retriever_embeddings = get_embeddings( | |
| self.retriever_name, | |
| all_contents, | |
| 'context' | |
| ) | |
| except Exception as e: | |
| self.logger.warning(f"Failed to batch compute retriever embeddings: {e}") | |
| all_success = False | |
| # Fall back to empty embeddings (operations will fail individually) | |
| all_retriever_embeddings = [None] * len(all_contents) | |
| # Batch compute state encoder embeddings if encoder is available | |
| all_state_encoder_embeddings = [] | |
| if all_contents and memory_bank.state_encoder is not None: | |
| try: | |
| all_state_encoder_embeddings = memory_bank.state_encoder._encode_texts(all_contents) | |
| except Exception as e: | |
| self.logger.warning(f"Failed to batch compute state encoder embeddings: {e}") | |
| # Fall back to None (memory_bank will compute individually if needed) | |
| all_state_encoder_embeddings = [None] * len(all_contents) | |
| else: | |
| all_state_encoder_embeddings = [None] * len(all_contents) | |
| # Split embeddings back to update and insert | |
| update_retriever_embeddings = all_retriever_embeddings[:len(updates)] | |
| update_state_encoder_embeddings = ( | |
| all_state_encoder_embeddings[:len(updates)] if len(all_state_encoder_embeddings) > 0 else [None] * len(updates) | |
| ) | |
| insert_retriever_embeddings = all_retriever_embeddings[len(updates):] | |
| insert_state_encoder_embeddings = ( | |
| all_state_encoder_embeddings[len(updates):] if len(all_state_encoder_embeddings) > 0 else [None] * len(inserts) | |
| ) | |
| # 1. Process UPDATEs first (before any DELETEs change indices) | |
| for i, result in enumerate(updates): | |
| try: | |
| actual_index = retrieved_indices[result.memory_index] | |
| retriever_emb = update_retriever_embeddings[i] | |
| state_encoder_emb = ( | |
| update_state_encoder_embeddings[i] if i < len(update_state_encoder_embeddings) else None | |
| ) | |
| if retriever_emb is None: | |
| raise ValueError("Retriever embedding is None") | |
| memory_bank.update_memory( | |
| index=actual_index, | |
| new_content=result.memory_content, | |
| new_embedding=retriever_emb, | |
| new_state_encoder_embedding=state_encoder_emb, | |
| operation_name=operation_name | |
| ) | |
| except Exception as e: | |
| self.logger.warning(f"Failed to apply UPDATE: {e}") | |
| all_success = False | |
| # 2. Process DELETEs in reverse order of *actual* memory bank indices to avoid index shift issues | |
| delete_targets = [] | |
| for result in deletes: | |
| try: | |
| actual_index = retrieved_indices[result.memory_index] | |
| delete_targets.append((actual_index, result)) | |
| except Exception as e: | |
| self.logger.warning(f"Failed to map DELETE target: {e}") | |
| all_success = False | |
| for actual_index, result in sorted(delete_targets, key=lambda x: x[0], reverse=True): | |
| try: | |
| memory_bank.delete_memory(index=actual_index) | |
| except Exception as e: | |
| self.logger.warning(f"Failed to apply DELETE: {e}") | |
| all_success = False | |
| # 3. Process INSERTs last (doesn't affect existing indices) | |
| for i, result in enumerate(inserts): | |
| try: | |
| retriever_emb = insert_retriever_embeddings[i] | |
| state_encoder_emb = ( | |
| insert_state_encoder_embeddings[i] if i < len(insert_state_encoder_embeddings) else None | |
| ) | |
| if retriever_emb is None: | |
| raise ValueError("Retriever embedding is None") | |
| memory_bank.add_memory( | |
| content=result.memory_content, | |
| embedding=retriever_emb, | |
| state_encoder_embedding=state_encoder_emb, | |
| metadata={'source': 'inserted'}, | |
| operation_name=operation_name | |
| ) | |
| except Exception as e: | |
| self.logger.warning(f"Failed to apply INSERT: {e}") | |
| all_success = False | |
| return all_success | |