mellea 0.0.1__py3-none-any.whl

cli/__init__.py

@@ -0,0 +1 @@
+"""cli for the M library."""

cli/alora/__init__.py

@@ -0,0 +1,2 @@
+# cli/alora/__init__.py
+"""alora command group package for training and uploading adapters."""

cli/alora/commands.py

@@ -0,0 +1,50 @@
+import typer
+
+alora_app = typer.Typer(
+    name="alora", help="Train or upload aLoRA models for requirement validator"
+)
+
+
+def alora_train(
+    datafile: str = typer.Argument(..., help="JSONL file with item/label pairs"),
+    basemodel: str = typer.Option(..., help="Base model ID or path"),
+    outfile: str = typer.Option(..., help="Path to save adapter weights"),
+    promptfile: str = typer.Option(None, help="Path to load the prompt format file"),
+    adapter: str = typer.Option("alora", help="Adapter type: alora or lora"),
+    epochs: int = typer.Option(6, help="Number of training epochs"),
+    learning_rate: float = typer.Option(6e-6, help="Learning rate"),
+    batch_size: int = typer.Option(2, help="Per-device batch size"),
+    max_length: int = typer.Option(1024, help="Max sequence length"),
+    grad_accum: int = typer.Option(4, help="Gradient accumulation steps"),
+):
+    """Train an aLoRA or LoRA model on your dataset."""
+    from cli.alora.train import train_model
+
+    train_model(
+        dataset_path=datafile,
+        base_model=basemodel,
+        output_file=outfile,
+        adapter=adapter,
+        epochs=epochs,
+        learning_rate=learning_rate,
+        batch_size=batch_size,
+        max_length=max_length,
+        grad_accum=grad_accum,
+        prompt_file=promptfile,
+    )
+
+
+def alora_upload(
+    weightfile: str = typer.Argument(..., help="Path to saved adapter weights"),
+    name: str = typer.Option(
+        ..., help="Destination model name (e.g., acme/carbchecker-alora)"
+    ),
+):
+    """Upload trained adapter to remote model registry."""
+    from cli.alora.upload import upload_model
+
+    upload_model(weight_path=weightfile, model_name=name)
+
+
+alora_app.command("train")(alora_train)
+alora_app.command("upload")(alora_upload)

cli/alora/train.py

@@ -0,0 +1,173 @@
+import json
+import os
+
+import typer
+from alora.config import aLoraConfig
+from alora.peft_model_alora import aLoRAPeftModelForCausalLM
+from datasets import Dataset
+from peft import LoraConfig, PeftModelForCausalLM
+from transformers import AutoModelForCausalLM, AutoTokenizer, TrainerCallback
+from trl import DataCollatorForCompletionOnlyLM, SFTConfig, SFTTrainer
+
+
+def load_dataset_from_json(json_path, tokenizer, invocation_prompt):
+    data = []
+    with open(json_path, encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                data.append(json.loads(line))
+
+    inputs = []
+    targets = []
+    for sample in data:
+        item_text = sample.get("item", "")
+        label_text = sample.get("label", "")
+        prompt = f"{item_text}\nRequirement: <|end_of_text|>\n{invocation_prompt}"
+        inputs.append(prompt)
+        targets.append(label_text)
+    return Dataset.from_dict({"input": inputs, "target": targets})
+
+
+def formatting_prompts_func(example):
+    return [
+        f"{example['input'][i]}{example['target'][i]}"
+        for i in range(len(example["input"]))
+    ]
+
+
+class SaveBestModelCallback(TrainerCallback):
+    def __init__(self):
+        self.best_eval_loss = float("inf")
+
+    def on_evaluate(self, args, state, control, **kwargs):
+        model = kwargs["model"]
+        metrics = kwargs["metrics"]
+        eval_loss = metrics.get("eval_loss")
+        if eval_loss is not None and eval_loss < self.best_eval_loss:
+            self.best_eval_loss = eval_loss
+            model.save_pretrained(args.output_dir)
+
+
+class SafeSaveTrainer(SFTTrainer):
+    def save_model(self, output_dir: str | None = None, _internal_call: bool = False):
+        if self.model is not None:
+            self.model.save_pretrained(output_dir, safe_serialization=True)
+            if self.tokenizer is not None:
+                self.tokenizer.save_pretrained(output_dir)
+
+
+def train_model(
+    dataset_path: str,
+    base_model: str,
+    output_file: str,
+    prompt_file: str | None = None,
+    adapter: str = "alora",
+    run_name: str = "multiclass_run",
+    epochs: int = 6,
+    learning_rate: float = 6e-6,
+    batch_size: int = 2,
+    max_length: int = 1024,
+    grad_accum: int = 4,
+):
+    if prompt_file:
+        # load the configurable variable invocation_prompt
+        with open(prompt_file) as f:
+            config = json.load(f)
+        invocation_prompt = config["invocation_prompt"]
+    else:
+        invocation_prompt = "<|start_of_role|>check_requirement<|end_of_role|>"
+
+    tokenizer = AutoTokenizer.from_pretrained(
+        base_model, padding_side="right", trust_remote_code=True
+    )
+    tokenizer.pad_token = tokenizer.eos_token
+    tokenizer.add_special_tokens = False
+
+    dataset = load_dataset_from_json(dataset_path, tokenizer, invocation_prompt)
+    dataset = dataset.shuffle(seed=42)
+    split_idx = int(len(dataset) * 0.8)
+    train_dataset = dataset.select(range(split_idx))
+    val_dataset = dataset.select(range(split_idx, len(dataset)))
+
+    model_base = AutoModelForCausalLM.from_pretrained(
+        base_model, device_map="auto", use_cache=False
+    )
+
+    collator = DataCollatorForCompletionOnlyLM(invocation_prompt, tokenizer=tokenizer)
+
+    output_dir = os.path.dirname(output_file)
+    os.makedirs(output_dir, exist_ok=True)
+
+    if adapter == "alora":
+        peft_config = aLoraConfig(
+            invocation_string=invocation_prompt,
+            r=32,
+            lora_alpha=32,
+            lora_dropout=0.05,
+            bias="none",
+            task_type="CAUSAL_LM",
+            target_modules=["q_proj", "k_proj", "v_proj"],
+        )
+        response_token_ids = tokenizer(
+            invocation_prompt, return_tensors="pt", add_special_tokens=False
+        )["input_ids"]
+        model = aLoRAPeftModelForCausalLM(
+            model_base, peft_config, response_token_ids=response_token_ids
+        )
+
+        sft_args = SFTConfig(
+            output_dir=output_dir,
+            dataset_kwargs={"add_special_tokens": False},
+            num_train_epochs=epochs,
+            learning_rate=learning_rate,
+            max_seq_length=max_length,
+            per_device_train_batch_size=batch_size,
+            gradient_accumulation_steps=grad_accum,
+            fp16=True,
+        )
+
+        trainer = SafeSaveTrainer(
+            model,
+            train_dataset=train_dataset,
+            eval_dataset=val_dataset,
+            args=sft_args,
+            formatting_func=formatting_prompts_func,
+            data_collator=collator,
+            callbacks=[SaveBestModelCallback()],
+        )
+        trainer.train()
+        model.save_pretrained(output_file)
+
+    else:
+        peft_config = LoraConfig(
+            r=6,
+            lora_alpha=32,
+            lora_dropout=0.05,
+            bias="none",
+            task_type="CAUSAL_LM",
+            target_modules=["q_proj", "k_proj", "v_proj"],
+        )
+        model = PeftModelForCausalLM(model_base, peft_config)
+
+        sft_args = SFTConfig(
+            output_dir=output_dir,
+            dataset_kwargs={"add_special_tokens": False},
+            num_train_epochs=epochs,
+            learning_rate=learning_rate,
+            max_seq_length=max_length,
+            per_device_train_batch_size=batch_size,
+            gradient_accumulation_steps=grad_accum,
+            fp16=True,
+        )
+
+        trainer = SafeSaveTrainer(
+            model,
+            train_dataset=train_dataset,
+            eval_dataset=val_dataset,
+            args=sft_args,
+            formatting_func=formatting_prompts_func,
+            data_collator=collator,
+        )
+        trainer.train()
+        model.save_pretrained(output_file, safe_serialization=True)

cli/alora/upload.py

@@ -0,0 +1,46 @@
+import os
+
+import typer
+from huggingface_hub import HfApi, HfFolder, create_repo, upload_folder
+
+
+def upload_model(weight_path: str, model_name: str, private: bool = True):
+    """
+    Upload a trained adapter (LoRA/aLoRA) to Hugging Face Hub.
+
+    Args:
+        weight_path (str): Directory containing adapter weights (from save_pretrained).
+        model_name (str): Target model repo name (e.g., "acme/carbchecker-alora").
+        private (bool): Whether the repo should be private. Default: True.
+
+    Requires:
+        - `HF_TOKEN` set in environment or via `huggingface-cli login`.
+    """
+    if not os.path.exists(weight_path):
+        raise FileNotFoundError(f"Adapter directory not found: {weight_path}")
+
+    # Create repo if not exists
+    token = HfFolder.get_token()
+    if token is None:
+        raise OSError(
+            "Hugging Face token not found. Run `huggingface-cli login` first."
+        )
+
+    try:
+        create_repo(repo_id=model_name, token=token, private=private, exist_ok=True)
+    except Exception as e:
+        raise RuntimeError(f"Failed to create or access repo {model_name}: {e}")
+
+    print(
+        f"Uploading adapter from '{weight_path}' to 'https://huggingface.co/{model_name}' ..."
+    )
+
+    upload_folder(
+        repo_id=model_name,
+        folder_path=weight_path,
+        path_in_repo=".",  # Root of repo
+        commit_message="Upload adapter weights",
+        token=token,
+    )
+
+    print("✅ Upload complete!")

cli/decomp/__init__.py

@@ -0,0 +1,2 @@
+# __init__.py
+# Empty file to make this a package

cli/decomp/prompts/__init__.py

@@ -0,0 +1 @@
+from . import metaprompts

cli/decomp/prompts/metaprompts/README.md

@@ -0,0 +1 @@
+# Generic Metaprompt v2.5

cli/decomp/prompts/metaprompts/__init__.py

@@ -0,0 +1,12 @@
+from .metaprompt_get_input_data import (
+    metaprompt_get_input_data__system,
+    metaprompt_get_input_data__user,
+)
+from .metaprompt_subtask_gen import (
+    metaprompt_subtask_gen__system,
+    metaprompt_subtask_gen__user,
+)
+from .metaprompt_subtask_list_tags import (
+    metaprompt_subtask_list__system,
+    metaprompt_subtask_list__user,
+)

cli/decomp/prompts/metaprompts/metaprompt_get_input_data.py

@@ -0,0 +1,65 @@
+# flake8: noqa
+
+metaprompt_get_input_data__system = """You will analyze a task prompt to determine whether it requires user-provided input data (variables) in order to be executed effectively. Not all tasks need input data — some may be general knowledge questions or self-contained instructions.
+
+The user input data / variables might be:
+- Explicitly indicated using a templating format like {{VARIABLE_NAME}}
+- Implicitly required, based on task understanding
+
+Your objective is to identify all the necessary user input data required to complete the task and present them in a specific format.
+
+Key Instructions:
+- If input variables are present, list them **inside curly braces**, using **UPPERCASE_WITH_UNDERSCORES** format and **comma-separated**, **no spaces**.
+- If no input data is needed, output `"N/A"` inside the `<User Input Data>` tags.
+- Do not include anything else in your response except the tags and the input list.
+
+---
+
+<Example>
+  <Task>
+    Generate a formal letter for a recipient based on their name, address, and the purpose of the letter.
+  </Task>
+  <User Input Data>
+    {{RECIPIENT_NAME}},{{RECIPIENT_ADDRESS}},{{LETTER_PURPOSE}}
+  </User Input Data>
+</Example>
+
+<Example>
+  <Task>
+    Explain the concept of Newton’s Laws of Motion with examples.
+  </Task>
+  <User Input Data>
+    N/A
+  </User Input Data>
+</Example>
+
+<Example>
+  <Task>
+    Produce a summary from a provided article text.
+  </Task>
+  <User Input Data>
+    {{ARTICLE_TEXT}}
+  </User Input Data>
+</Example>
+
+That concludes the examples.
+"""
+
+metaprompt_get_input_data__user = """Now, here is the task prompt for which I would like you to identify and list all the user input data (variables) names:
+
+<Task>
+{{TASK}}
+</Task>
+
+To write your user input data (variables) list, follow THESE instructions:
+1. Use your best judgement to create the user input data (variable) names.
+2. The user input data (variable) names must be written surrounded by curly braces.
+3. The user input data (variable) names must be written in uppercase letters and if the name is composed by multiple words, the words must be separated by a underscore character (_) instead o spaces.
+4. In <User Input Data> tags, write your user input data (variables) list. This user input data (variables) list should be similarly structured as the ones in the examples above. Always close the user input data (variables) list section with the </User Input Data> tag.
+5. If you judge that the provided task does not need user input data to be completed, then you must write "N/A" (without the quotes) inside the <User Input Data> tags and nothing else, just close the tags.
+6. Do not forget to always close each section with its corresponding close tag.
+
+Note: This is probably obvious to you already, but you are not *completing* the task here. You are just writing the user input data list for an AI to complete the task later.
+Note: Remember that not all tasks need user input data, usually smaller tasks and tasks that are just asking for information don't require user input data, use your best judgment to identify those.
+Note: You must write ONLY the user input data list, do not repeat the long complex task provided.
+"""

cli/decomp/prompts/metaprompts/metaprompt_subtask_gen.py

@@ -0,0 +1,135 @@
+# flake8: noqa
+
+metaprompt_subtask_gen__system = """You are writing instructions to guide a helpful but inexperienced AI assistant to complete part of a larger task. Your role is to generate a *step-level prompt instruction* that the assistant will use to complete a specific step of a long, complex task.
+
+You will receive four parameters:
+1. A long complex task, provided inside <Long Complex Task> tags.
+2. A specific execution step from that task, inside <Step> tags.
+3. A list of previous steps (with variable names) that were already completed, inside <Previous Steps> tags.
+4. A list of available input variables (user input and previous step results), inside <Available Input Variables> tags.
+
+Your job is to:
+- Write a clear and complete **<Step Prompt Instruction>** that helps the assistant complete the given step, using only relevant parts of the long complex task.
+- Use consistent terminology and style from the long complex task.
+- If prior step outputs are useful, include them using their variable names in `{{double_curly_braces}}`. Wrap them in triple backticks (```...```) when referencing outputs.
+- Reference user input variables using `{{VARIABLE_NAME}}` placeholders where needed.
+
+Next, analyze whether the current step has specific **requirements or conditions**. If so, write them in bullet points using the same wording from the long complex task and enclose them in <Requirements and Conditions> tags. If none are applicable, write `"N/A"` inside the tag.
+
+Here are a few generic examples:
+
+<Example>
+  <Long Complex Task>
+    This task involves analyzing a dataset to produce a statistical summary report.
+
+    Instructions:
+    1. Load the input dataset.
+    2. Clean the dataset by removing nulls and outliers.
+    3. Generate basic descriptive statistics.
+    4. Write a brief natural language summary of the statistics.
+
+    Your output should be in JSON format with two keys: `stats` and `summary`.
+  </Long Complex Task>
+  <Step>
+    2. Clean the dataset by removing nulls and outliers.
+  </Step>
+  <Previous Steps>
+    1. Load the input dataset. - Variable: RAW_DATA
+  </Previous Steps>
+  <Available Input Variables>
+    {{RAW_DATA}}
+  </Available Input Variables>
+  <Step Prompt Instruction>
+    Clean the dataset provided below by performing the following:
+    - Remove any rows with null or missing values
+    - Remove outliers using appropriate statistical techniques
+
+    Input dataset:
+    ```
+    {{RAW_DATA}}
+    ```
+
+    Return the cleaned dataset.
+  </Step Prompt Instruction>
+  <Requirements and Conditions>
+    - Remove any rows with null or missing values
+    - Remove outliers using appropriate statistical techniques
+  </Requirements and Conditions>
+</Example>
+
+<Example>
+  <Long Complex Task>
+    You will write a brief summary of a user-submitted document, capturing key ideas and structure.
+
+    Instructions:
+    1. Read and analyze the input document.
+    2. Identify the key themes and main ideas.
+    3. Write a summary in under 200 words, preserving the tone and style of the input.
+
+    Return your result as a string.
+  </Long Complex Task>
+  <Step>
+    3. Write a summary in under 200 words, preserving the tone and style of the input.
+  </Step>
+  <Previous Steps>
+    1. Read and analyze the input document. - Variable: DOCUMENT_ANALYSIS
+    2. Identify the key themes and main ideas. - Variable: KEY_THEMES
+  </Previous Steps>
+  <Available Input Variables>
+    {{DOCUMENT_ANALYSIS}},{{KEY_THEMES}}
+  </Available Input Variables>
+  <Step Prompt Instruction>
+    Using the analysis and themes identified in the previous steps:
+    - Write a concise summary of the input content.
+    - Keep it under 200 words.
+    - Maintain the tone and style of the original document.
+
+    Previous analysis:
+    ```
+    {{DOCUMENT_ANALYSIS}}
+    ```
+
+    Key themes:
+    ```
+    {{KEY_THEMES}}
+    ```
+  </Step Prompt Instruction>
+  <Requirements and Conditions>
+    - Keep the summary under 200 words
+    - Maintain the tone and style of the input document
+  </Requirements and Conditions>
+</Example>
+
+That concludes the examples."""
+
+metaprompt_subtask_gen__user = """Now, here are the 4 parameters (<Long Complex Task>, <Step>, <Previous Steps>, <Available Input Variables>) which I would like you to use to write your <Step Prompt Instruction> and <Requirements and Conditions>:
+
+<Long Complex Task>
+{{TASK}}
+</Long Complex Task>
+<Step>
+{{STEP}}
+</Step>
+<Previous Steps>
+{{PREVIOUS_STEPS}}
+</Previous Steps>
+<Available Input Variables>
+{{INPUT_DATA}}
+</Available Input Variables>
+
+To write your step "prompt instruction" and your "requirements and conditions", pay attention to these instructions:
+1. In <Step Prompt Instruction> tags, write the prompt instruction to execute and complete the provided step (<Step> tags). Always close the prompt instruction section with the </Step Prompt Instruction> tag.
+2. Consider and use the variables in the <Available Input Variables> tags to write your template.
+3. In <Requirements and Conditions> tags, identify and write all requirements and conditions closely related to the provided step (<Step> tags). Always close the requirements and conditions section with the </Requirements and Conditions> tag.
+4. The <Requirements and Conditions> should include only requirements and conditions that are are closely related to the task in the <Step> tags and mentioned in the long complex task. The <Long Complex Task> must be the only scope for writing your <Requirements and Conditions> list.
+5. Use, as much as you can, the same words and style as provided in the long complex task content (<Long Complex Task> tags).
+6. Do not forget to always close each section with its corresponding close tag.
+7. Don't forget to close the <Requirements and Conditions> tags at the end of your response.
+
+Note: This is probably obvious to you already, but you are not *completing* the task here. You are writing instructions for an AI to complete the task.
+Note: Another name for what you are writing is a "prompt template". When you put a variable name enclosed in double brackets into this template, it will later have the full value (which will be provided by a user or by the result from a previous step) substituted into it.
+Note: When referencing the result of a previous step using its variable name on your instructions prompt template, you usually place the variable inside triple backquote characters (```). Example: \n```\n{{VARIABLE_NAME}}\n```\n
+Note: When writing the requirements and conditions, do not reference and do not use the result of previous steps to write detected requirements. Don't use input variables inside the <Requirements and Conditions> tags.
+
+It is extremely important to always close the <Requirements and Conditions> tags with "</Requirements and Conditions>" at the end of your answer.
+"""

cli/decomp/prompts/metaprompts/metaprompt_subtask_list_tags.py

@@ -0,0 +1,101 @@
+# flake8: noqa
+
+metaprompt_subtask_list__system = """You will break down a long, complex task into a list of subtasks for a helpful but inexperienced AI assistant to execute in order. Your goal is to make the task easier to complete by structuring it into logically ordered, actionable subtasks.
+
+You will generate:
+1. A <Reasoning> section to reflect on the structure and needs of the task.
+2. A <Draft Subtask List> where you write an initial set of subtasks, each tagged with a classification type from the list below.
+3. A <Final Subtask List> with fewer, cleaner steps, each labeled with a variable name related to its purpose.
+
+Use the following classification types in the draft list:
+- "write"
+- "extract"
+- "present or show"
+- "reason and reflect"
+- "research"
+- "assert and verify"
+- "constraints and conditions"
+- "format"
+- "safety and security"
+
+For the <Final Subtask List>:
+- Use numbered steps (no subitems or multiline descriptions).
+- Each step must describe a single, self-contained action.
+- Assign each step a variable name using **UPPERCASE_WITH_UNDERSCORES** enclosed in `Variable: ...`.
+- These variable names should reflect the intent or output of that step.
+
+Here is an example:
+
+<Final Subtask List>
+1. Gather and understand the task input requirements. - Variable: INPUT_DATA
+2. Conduct research or analysis using the task input. - Variable: RESEARCH
+3. Write a structured result that satisfies the task requirements. - Variable: OUTPUT
+</Final Subtask List>
+
+Now see some full examples:
+
+<Example>
+  <Long Complex Task>
+    Create a short, informative summary from a document that contains paragraphs of raw text. The summary should capture key ideas and tone of the original. Write the output in plain language and return it as a paragraph.
+  </Long Complex Task>
+  <Reasoning>
+    The task requires understanding the document, extracting core content, rephrasing the core content in plain language, and writing a concise summary. We must also ensure that the output respects the tone and content focus of the original document.
+  </Reasoning>
+  <Draft Subtask List>
+    1. Validate that the input document does not contain inappropriate or harmful content. - Category "safety and security"
+    2. Extract the main themes and important ideas from the text. - Category "extract"
+    3. Reflect on the tone and style of the input. - Category "reason and reflect"
+    4. Write a short summary paragraph in plain language. - Category "write"
+    5. Format the output for clean paragraph structure. - Category "format"
+    6. Verify that the summary preserves original tone and covers key points. - Category "assert and verify"
+  </Draft Subtask List>
+  <Final Subtask List>
+    1. Extract and reflect on the main ideas and tone from the document. - Variable: CONTENT_OVERVIEW
+    2. Write a short, plain-language summary using the extracted information. - Variable: SUMMARY
+  </Final Subtask List>
+</Example>
+
+<Example>
+  <Long Complex Task>
+    Analyze a dataset and create a visualization that shows the distribution of numerical values for a selected feature. Include descriptive labels and a brief caption explaining the visual.
+  </Long Complex Task>
+  <Reasoning>
+    To complete this task, we need to first load and verify the dataset. Then we analyze the selected feature and generate a visualization like a histogram or boxplot. The visual must be labeled properly, and a clear caption must be added to interpret it.
+  </Reasoning>
+  <Draft Subtask List>
+    1. Load the dataset and check its format and integrity. - Category "assert and verify"
+    2. Extract the values of the selected numerical feature. - Category "extract"
+    3. Generate a visual distribution chart. - Category "present or show"
+    4. Write a descriptive caption that explains what the chart shows. - Category "write"
+    5. Add labels and format the chart. - Category "format"
+  </Draft Subtask List>
+  <Final Subtask List>
+    1. Extract the values for the selected feature from the dataset. - Variable: FEATURE_DATA
+    2. Generate a chart and caption showing the feature’s distribution. - Variable: VISUALIZATION
+  </Final Subtask List>
+</Example>
+
+That concludes the examples."""
+
+metaprompt_subtask_list__user = """Now, here is the prompt of the long complex task for which I would like you to break down and write both subtask lists:
+
+<Long Complex Task>
+{{TASK}}
+</Long Complex Task>
+
+To write your subtask lists, follow THESE instructions:
+1. In <Reasoning> tags, reason and think about the provided task and plan out how you will structure your subtasks in a correct order of execution. Always close the reasoning section with the </Reasoning> tag.
+2. In <Draft Subtask List> tags, write your proposed draft subtask list. This draft subtask list should be similarly structured as the ones in the examples above. Always close the draft subtask list section with the </Draft Subtask List> tag.
+3. Remember to classify each step on the <Draft Subtask List> under categories (types): "write", "extract", "present or show", "reason and reflect", "research", "assert and verify", "constraints and conditions", "format", "safety and security".
+4. In <Final Subtask List> tags, write the subtask list. The subtask list should be based on the draft subtask list, but must have FEWER steps, you can have less steps by either grouping steps together or by omitting steps of specific categories that do not describe an actual action. This final subtask list should be similarly structured as the ones in the examples above. Always close the subtask list section with the </Final Subtask List> tag.
+5. When writing the <Final Subtask List> try to group steps and remove non-actionable steps, but maintain the step's text very descriptive of its action.
+6. Do not forget to always close each section with its corresponding close tag.
+7. It is extremely important to always make sure both subtask lists are NUMBERED lists and that each item is a single-line, do not use new lines when writing the subtask lists and do not add subitems.
+
+Note: This is probably obvious to you already, but you are not *completing* the task here. You are just writing a subtask list for an AI to follow and complete the task.
+Note: The final <Final Subtask List> must omit steps of the categories such as "assert and verify", "present or show", "constraints and conditions", and "safety and security".
+Note: When writing your <Final Subtask List>, you must try *MINIMIZE* the number of steps in the final list.
+Note: The final <Final Subtask List> must NOT include the categories in the list, but it should include the "Variable" name based on the step's content.
+
+Important: Do not forget to always close the <Final Subtask List> tag with "</Final Subtask List>" in the last line of your answer.
+"""