ara-cli 0.1.9.73__py3-none-any.whl → 0.1.9.75__py3-none-any.whl

ara_cli/artefact_models/artefact_model.py

@@ -1,5 +1,5 @@
 from pydantic import BaseModel, Field, field_validator, model_validator
-from typing import Optional, List, Literal, Union, Dict
+from typing import Optional, List, Literal, Union, Dict, ClassVar
 from typing_extensions import Self
 from enum import Enum
 from abc import ABC, abstractmethod
@@ -47,13 +47,23 @@ class Contribution(BaseModel):
         description="Rule the contribution is using. The classifier of the parent must be userstory or epic if this is used"
     )
 
+    PLACEHOLDER_NAME: ClassVar[str] = "<filename or title of the artefact>"
+    PLACEHOLDER_CLASSIFIER: ClassVar[str] = "<agile requirement artefact category> <(optional in case the contribution is to an artefact that is detailed with rules)"
+    PLACEHOLDER_RULE: ClassVar[str] = "<rule as it is formulated>"
+
     @model_validator(mode="after")
     def validate_parent(self) -> Self:
-
         artefact_name = self.artefact_name
         classifier = self.classifier
         rule = self.rule
 
+        if (
+            artefact_name == Contribution.PLACEHOLDER_NAME
+            or classifier == Contribution.PLACEHOLDER_CLASSIFIER
+            or rule == Contribution.PLACEHOLDER_RULE
+        ):
+            return self
+
         if artefact_name:
             artefact_name = replace_space_with_underscore(artefact_name)
         if not artefact_name or not classifier:
@@ -68,7 +78,7 @@ class Contribution(BaseModel):
 
     @field_validator('artefact_name')
     def validate_artefact_name(cls, value):
-        if not value:
+        if not value or value == Contribution.PLACEHOLDER_NAME:
             return value
         if ' ' in value:
             warnings.warn(message="artefact_name can not contain spaces. Replacing spaces with '_'")
@@ -77,7 +87,7 @@ class Contribution(BaseModel):
 
     @field_validator('classifier', mode='after')
     def validate_classifier(cls, v):
-        if not v:
+        if not v or v == Contribution.PLACEHOLDER_CLASSIFIER:
             return v
         try:
             return ArtefactType(v)
@@ -91,12 +101,21 @@ class Contribution(BaseModel):
         if not line.startswith(contribution_line_start):
             raise ValueError(f"Contribution line '{line}' does not start with '{contribution_line_start}'")
 
+        parent_text = line[len(contribution_line_start):].strip()
+        rule_specifier = " using rule "
+
+        placeholder_line = f"{cls.PLACEHOLDER_NAME} {cls.PLACEHOLDER_CLASSIFIER}{rule_specifier}{cls.PLACEHOLDER_RULE}"
+        if parent_text == placeholder_line:
+            return cls(
+                artefact_name=cls.PLACEHOLDER_NAME,
+                classifier=cls.PLACEHOLDER_CLASSIFIER,
+                rule=cls.PLACEHOLDER_RULE
+            )
+
         artefact_name = None
         classifier = None
         rule = None
 
-        parent_text = line[len(contribution_line_start):].strip()
-        rule_specifier = " using rule "
         if rule_specifier in parent_text:
             parent_text, rule_text = parent_text.split(rule_specifier, 1)
             rule = rule_text
@@ -113,7 +132,7 @@ class Contribution(BaseModel):
     def serialize(self) -> str:
         if not self.classifier or not self.artefact_name:
             return ""
-        artefact_type = Classifier.get_artefact_title(self.classifier)
+        artefact_type = Classifier.get_artefact_title(self.classifier) or self.classifier
         artefact_name = replace_underscore_with_space(self.artefact_name)
         contribution = f"{artefact_name} {artefact_type}"
         if self.rule:

ara_cli/artefact_models/artefact_templates.py

@@ -1,4 +1,4 @@
-from ara_cli.artefact_models.artefact_model import ArtefactType, Artefact
+from ara_cli.artefact_models.artefact_model import ArtefactType, Artefact, Contribution
 from ara_cli.artefact_models.vision_artefact_model import VisionArtefact, VisionIntent
 from ara_cli.artefact_models.businessgoal_artefact_model import BusinessgoalArtefact, BusinessgoalIntent
 from ara_cli.artefact_models.capability_artefact_model import CapabilityArtefact, CapabilityIntent
@@ -11,7 +11,15 @@ from ara_cli.artefact_models.task_artefact_model import TaskArtefact
 from ara_cli.artefact_models.issue_artefact_model import IssueArtefact
 
 
-def _default_vision(title: str) -> VisionArtefact:
+def default_contribution() -> Contribution:
+    return Contribution(
+        artefact_name=Contribution.PLACEHOLDER_NAME,
+        classifier=Contribution.PLACEHOLDER_CLASSIFIER,
+        rule=Contribution.PLACEHOLDER_RULE
+    )
+
+
+def _default_vision(title: str, use_default_contribution: bool) -> VisionArtefact:
     intent = VisionIntent(
         for_="<target customer>",
         who="<needs something>",
@@ -24,11 +32,12 @@ def _default_vision(title: str) -> VisionArtefact:
         tags=["sample_tag"],
         title=title,
         description="<further optional description to understand the vision, markdown capable text formatting>",
-        intent=intent
+        intent=intent,
+        contribution=default_contribution() if use_default_contribution else None
     )
 
 
-def _default_businessgoal(title: str) -> BusinessgoalArtefact:
+def _default_businessgoal(title: str, use_default_contribution: bool) -> BusinessgoalArtefact:
     intent = BusinessgoalIntent(
         in_order_to="<reach primarily a monetary business goal>",
         as_a="<business related role>",
@@ -37,26 +46,26 @@ def _default_businessgoal(title: str) -> BusinessgoalArtefact:
     return BusinessgoalArtefact(
         tags=["sample_tag"],
         title=title,
-        description="<further optional description to understand the vision, markdown capable text formatting>",
-        intent=intent
+        description="<further optional description to understand the businessgoal, markdown capable text formatting>",
+        intent=intent,
+        contribution=default_contribution() if use_default_contribution else None
     )
 
 
-def _default_capability(title: str) -> CapabilityArtefact:
+def _default_capability(title: str, use_default_contribution: bool) -> CapabilityArtefact:
     intent = CapabilityIntent(
-        in_order_to="<reach primarily a monetary business goal>",
-        as_a="<business related role>",
-        to_be_able_to="<something that helps me to reach my monetary goal>"
+        to_be_able_to="<needed capability for stakeholders that are the enablers/relevant for reaching the business goal>"
     )
     return CapabilityArtefact(
         tags=["sample_tag"],
         title=title,
         description="<further optional description to understand the capability, markdown capable text formatting>",
-        intent=intent
+        intent=intent,
+        contribution=default_contribution() if use_default_contribution else None
     )
 
 
-def _default_epic(title: str) -> EpicArtefact:
+def _default_epic(title: str, use_default_contribution: bool) -> EpicArtefact:
     intent = EpicIntent(
         in_order_to="<achieve a benefit>",
         as_a="<(user) role>",
@@ -70,13 +79,14 @@ def _default_epic(title: str) -> EpicArtefact:
     return EpicArtefact(
         tags=["sample_tag"],
         title=title,
-        description="<further optional description to understand the vision, markdown capable text formatting>",
+        description="<further optional description to understand the epic, markdown capable text formatting>",
         intent=intent,
-        rules=rules
+        rules=rules,
+        contribution=default_contribution() if use_default_contribution else None
     )
 
 
-def _default_userstory(title: str) -> UserstoryArtefact:
+def _default_userstory(title: str, use_default_contribution: bool) -> UserstoryArtefact:
     intent = UserstoryIntent(
         in_order_to="<achieve a benefit>",
         as_a="<(user) role>",
@@ -93,25 +103,27 @@ def _default_userstory(title: str) -> UserstoryArtefact:
         description="<further optional description to understand the userstory, markdown capable text formatting>",
         intent=intent,
         rules=rules,
-        estimate="<story points, scale?>"
+        estimate="<story points, scale?>",
+        contribution=default_contribution() if use_default_contribution else None
     )
 
 
-def _default_example(title: str) -> ExampleArtefact:
+def _default_example(title: str, use_default_contribution: bool) -> ExampleArtefact:
     return ExampleArtefact(
         tags=["sample_tag"],
         title=title,
         description="<further optional description to understand the example, markdown capable text formatting>",
+        contribution=default_contribution() if use_default_contribution else None
     )
 
 
-def _default_keyfeature(title: str) -> KeyfeatureArtefact:
+def _default_keyfeature(title: str, use_default_contribution: bool) -> KeyfeatureArtefact:
     intent = KeyfeatureIntent(
         in_order_to="<support a capability or business goal>",
         as_a="<main stakeholder who will benefit>",
         i_want="<a product feature that helps me doing something so that I can achieve my named goal>"
     )
-    description = """<further optional description to understand the capability, markdown capable text formatting, best practice is using
+    description = """<further optional description to understand the keyfeature, markdown capable text formatting, best practice is using
     GIVEN any precondition
     AND another precondition
     WHEN some action takes place
@@ -121,11 +133,12 @@ def _default_keyfeature(title: str) -> KeyfeatureArtefact:
         tags=["sample_tag"],
         title=title,
         description=description,
-        intent=intent
+        intent=intent,
+        contribution=default_contribution() if use_default_contribution else None
     )
 
 
-def _default_feature(title: str) -> FeatureArtefact:
+def _default_feature(title: str, use_default_contribution: bool) -> FeatureArtefact:
     intent = FeatureIntent(
         as_a="<user>",
         i_want_to="<do something | need something>",
@@ -169,27 +182,28 @@ def _default_feature(title: str) -> FeatureArtefact:
             ]
         )
     ]
-    description = """<further optional description to understand
-  the rule, no format defined, the example artefact is only a placeholder>"""
+    description = """<further optional description to understand the feature, no format defined, the example artefact is only a placeholder>"""
 
     return FeatureArtefact(
         tags=["sample_tag"],
         title=title,
         description=description,
         intent=intent,
-        scenarios=scenarios
+        scenarios=scenarios,
+        contribution=default_contribution() if use_default_contribution else None
     )
 
 
-def _default_task(title: str) -> TaskArtefact:
+def _default_task(title: str, use_default_contribution: bool) -> TaskArtefact:
     return TaskArtefact(
         status="to-do",
         title=title,
-        description="<further optional description to understand the task, no format defined>"
+        description="<further optional description to understand the task, no format defined>",
+        contribution=default_contribution() if use_default_contribution else None
     )
 
 
-def _default_issue(title: str) -> IssueArtefact:
+def _default_issue(title: str, use_default_contribution: bool) -> IssueArtefact:
     description = "<further free text description to understand the issue, no format defined>"
     additional_description = """*Optional descriptions of the issue in Gherkin style*
 
@@ -203,11 +217,12 @@ def _default_issue(title: str) -> IssueArtefact:
         tags=["sample_tag"],
         title=title,
         description=description,
-        additional_description=additional_description
+        additional_description=additional_description,
+        contribution=default_contribution() if use_default_contribution else None
     )
 
 
-def template_artefact_of_type(artefact_type: ArtefactType, title: str = "<descriptive_title>") -> Artefact:
+def template_artefact_of_type(artefact_type: ArtefactType, title: str = "<descriptive_title>", use_default_contribution: bool = True) -> Artefact:
     default_creation_functions = {
         ArtefactType.vision: _default_vision,
         ArtefactType.businessgoal: _default_businessgoal,
@@ -220,5 +235,6 @@ def template_artefact_of_type(artefact_type: ArtefactType, title: str = "<descri
         ArtefactType.task: _default_task,
         ArtefactType.issue: _default_issue
     }
-
-    return default_creation_functions[artefact_type](title)
+    if artefact_type not in default_creation_functions.keys():
+        return None
+    return default_creation_functions[artefact_type](title, use_default_contribution)

ara_cli/artefact_models/businessgoal_artefact_model.py

@@ -38,7 +38,7 @@ class BusinessgoalIntent(Intent):
         lines = []
 
         as_a_line = as_a_serializer(self.as_a)
-        
+
         lines.append(f"In order to {self.in_order_to}")
         lines.append(as_a_line)
         lines.append(f"I want {self.i_want}")
@@ -47,39 +47,37 @@ class BusinessgoalIntent(Intent):
 
     @classmethod
     def deserialize_from_lines(cls, lines: List[str], start_index: int = 0) -> 'BusinessgoalIntent':
-        in_order_to = None
-        as_a = None
-        i_want = None
-
-        in_order_to_prefix = "In order to "
-        as_a_prefix = "As a "
-        as_a_prefix_alt = "As an "
-        i_want_prefix = "I want "
+        prefixes = [
+            ("In order to ", "in_order_to"),
+            ("As a ", "as_a"),
+            ("As an ", "as_a"),
+            ("I want ", "i_want"),
+        ]
+        found = {"in_order_to": None, "as_a": None, "i_want": None}
+
+        def match_and_store(line):
+            for prefix, field in prefixes:
+                if line.startswith(prefix) and found[field] is None:
+                    found[field] = line[len(prefix):].strip()
+                    return True
+            return False
 
         index = start_index
-        while index < len(lines) and (not in_order_to or not as_a or not i_want):
-            line = lines[index]
-            if line.startswith(in_order_to_prefix) and not in_order_to:
-                in_order_to = line[len(in_order_to_prefix):].strip()
-            elif line.startswith(as_a_prefix) and not as_a:
-                as_a = line[len(as_a_prefix):].strip()
-            elif line.startswith(as_a_prefix_alt) and not as_a:
-                as_a = line[len(as_a_prefix_alt):].strip()
-            elif line.startswith(i_want_prefix) and not i_want:
-                i_want = line[len(i_want_prefix):].strip()
+        while index < len(lines) and any(v is None for v in found.values()):
+            match_and_store(lines[index])
             index += 1
 
-        if not in_order_to:
+        if not found["in_order_to"]:
             raise ValueError("Could not find 'In order to' line")
-        if not as_a:
+        if not found["as_a"]:
             raise ValueError("Could not find 'As a' line")
-        if not i_want:
+        if not found["i_want"]:
             raise ValueError("Could not find 'I want' line")
 
         return cls(
-            in_order_to=in_order_to,
-            as_a=as_a,
-            i_want=i_want
+            in_order_to=found["in_order_to"],
+            as_a=found["as_a"],
+            i_want=found["i_want"]
         )
 
 

ara_cli/artefact_models/epic_artefact_model.py

@@ -48,39 +48,38 @@ class EpicIntent(Intent):
 
     @classmethod
     def deserialize_from_lines(cls, lines: List[str], start_index: int = 0) -> 'EpicIntent':
-        in_order_to = None
-        as_a = None
-        i_want = None
-
-        in_order_to_prefix = "In order to "
-        as_a_prefix = "As a "
-        as_a_prefix_alt = "As an "
-        i_want_prefix = "I want "
+        prefixes = [
+            ("In order to ", "in_order_to"),
+            ("As a ", "as_a"),
+            ("As an ", "as_a"),
+            ("I want ", "i_want"),
+        ]
+
+        found = {"in_order_to": None, "as_a": None, "i_want": None}
+
+        def match_and_store(line):
+            for prefix, field in prefixes:
+                if line.startswith(prefix) and found[field] is None:
+                    found[field] = line[len(prefix):].strip()
+                    return True
+            return False
 
         index = start_index
-        while index < len(lines) and (not in_order_to or not as_a or not i_want):
-            line = lines[index]
-            if line.startswith(in_order_to_prefix) and not in_order_to:
-                in_order_to = line[len(in_order_to_prefix):].strip()
-            elif line.startswith(as_a_prefix) and not as_a:
-                as_a = line[len(as_a_prefix):].strip()
-            elif line.startswith(as_a_prefix_alt) and not as_a:
-                as_a = line[len(as_a_prefix_alt):].strip()
-            elif line.startswith(i_want_prefix) and not i_want:
-                i_want = line[len(i_want_prefix):].strip()
+        while index < len(lines) and any(v is None for v in found.values()):
+            match_and_store(lines[index])
             index += 1
 
-        if not in_order_to:
+        if not found["in_order_to"]:
             raise ValueError("Could not find 'In order to' line")
-        if not as_a:
+        if not found["as_a"]:
             raise ValueError("Could not find 'As a' line")
-        if not i_want:
+        if not found["i_want"]:
             raise ValueError("Could not find 'I want' line")
 
         return cls(
-            in_order_to=in_order_to,
-            as_a=as_a,
-            i_want=i_want
+            in_order_to=found["in_order_to"],
+            as_a=found["as_a"],
+            i_want=found["i_want"]
         )
 
 

ara_cli/artefact_models/feature_artefact_model.py

@@ -48,39 +48,36 @@ class FeatureIntent(Intent):
 
     @classmethod
     def deserialize_from_lines(cls, lines: List[str], start_index: int = 0) -> 'FeatureIntent':
-        as_a = None
-        i_want_to = None
-        so_that = None
-
-        as_a_prefix = "As a "
-        as_a_prefix_alt = "As an "
-        i_want_to_prefix = "I want to "
-        so_that_prefix = "So that "
+        prefixes = [
+            ("As a ", "as_a"),
+            ("As an ", "as_a"),
+            ("I want to ", "i_want_to"),
+            ("So that ", "so_that"),
+        ]
+        found = {"as_a": None, "i_want_to": None, "so_that": None}
+
+        def match_and_store(line):
+            for prefix, field in prefixes:
+                if line.startswith(prefix) and found[field] is None:
+                    found[field] = line[len(prefix):].strip()
+                    return
 
         index = start_index
-        while index < len(lines) and (not as_a or not i_want_to or not so_that):
-            line = lines[index]
-            if line.startswith(as_a_prefix) and not as_a:
-                as_a = line[len(as_a_prefix):].strip()
-            if line.startswith(as_a_prefix_alt) and not as_a:
-                as_a = line[len(as_a_prefix_alt):].strip()
-            if line.startswith(i_want_to_prefix) and not i_want_to:
-                i_want_to = line[len(i_want_to_prefix):].strip()
-            if line.startswith(so_that_prefix) and not so_that:
-                so_that = line[len(so_that_prefix):].strip()
+        while index < len(lines) and any(v is None for v in found.values()):
+            match_and_store(lines[index].strip())
             index += 1
 
-        if not as_a:
+        if not found["as_a"]:
             raise ValueError("Could not find 'As a' line")
-        if not i_want_to:
+        if not found["i_want_to"]:
             raise ValueError("Could not find 'I want to' line")
-        if not so_that:
+        if not found["so_that"]:
             raise ValueError("Could not find 'So that' line")
 
         return cls(
-            as_a=as_a,
-            i_want_to=i_want_to,
-            so_that=so_that
+            as_a=found["as_a"],
+            i_want_to=found["i_want_to"],
+            so_that=found["so_that"]
         )
 
 
@@ -138,6 +135,7 @@ class Scenario(BaseModel):
     @field_validator('title')
     def validate_title(cls, v: str) -> str:
         v = v.strip()
+        v = v.replace('_', ' ')
         if not v:
             raise ValueError("title must not be empty")
         return v
@@ -181,6 +179,7 @@ class ScenarioOutline(BaseModel):
     def validate_title(cls, v: str) -> str:
         if not v:
             raise ValueError("title must not be empty in a ScenarioOutline")
+        v = v.replace('_', ' ')
         return v
 
     @field_validator('steps', mode='before')
@@ -213,28 +212,54 @@ class ScenarioOutline(BaseModel):
     def from_lines(cls, lines: List[str], start_idx: int) -> Tuple['ScenarioOutline', int]:
         """Parse a ScenarioOutline from a list of lines starting at start_idx."""
 
-        if not lines[start_idx].startswith('Scenario Outline:'):
-            raise ValueError("Expected 'Scenario Outline:' at start index")
-        title = lines[start_idx][len('Scenario Outline:'):].strip()
-        steps = []
-        idx = start_idx + 1
-        while idx < len(lines) and not lines[idx].strip().startswith('Examples:'):
-            if lines[idx].strip():
-                steps.append(lines[idx].strip())
-            idx += 1
-        examples = []
-        if idx < len(lines) and lines[idx].strip() == 'Examples:':
+        def extract_title(line: str) -> str:
+            if not line.startswith('Scenario Outline:'):
+                raise ValueError("Expected 'Scenario Outline:' at start index")
+            return line[len('Scenario Outline:'):].strip()
+
+        def extract_steps(lines: List[str], idx: int) -> Tuple[List[str], int]:
+            steps = []
+            while idx < len(lines) and not lines[idx].strip().startswith('Examples:'):
+                if lines[idx].strip():
+                    steps.append(lines[idx].strip())
+                idx += 1
+            return steps, idx
+
+        def extract_headers(line: str) -> List[str]:
+            return [h.strip() for h in line.split('|') if h.strip()]
+
+        def extract_row(line: str) -> List[str]:
+            return [cell.strip() for cell in line.split('|') if cell.strip()]
+
+        def is_scenario_line(line: str) -> bool:
+            return line.startswith("Scenario:") or line.startswith("Scenario Outline:")
+
+        def extract_examples(lines: List[str], idx: int) -> Tuple[List['Example'], int]:
+            examples = []
+
+            if idx >= len(lines) or lines[idx].strip() != 'Examples:':
+                return examples, idx
+
             idx += 1
-            headers = [h.strip() for h in lines[idx].split('|') if h.strip()]
+            headers = extract_headers(lines[idx])
             idx += 1
-            while idx < len(lines) and lines[idx].strip():
-                if lines[idx].strip().startswith("Scenario:") or lines[idx].strip().startswith("Scenario Outline:"):
+
+            while idx < len(lines):
+                current_line = lines[idx].strip()
+                if not current_line or is_scenario_line(current_line):
                     break
-                row = [cell.strip()
-                       for cell in lines[idx].split('|') if cell.strip()]
+
+                row = extract_row(lines[idx])
                 example = Example.from_row(headers, row)
                 examples.append(example)
                 idx += 1
+
+            return examples, idx
+
+        title = extract_title(lines[start_idx])
+        steps, idx = extract_steps(lines, start_idx + 1)
+        examples, idx = extract_examples(lines, idx)
+
         return cls(title=title, steps=steps, examples=examples), idx
 
 
@@ -289,12 +314,10 @@ class FeatureArtefact(Artefact):
 
     def _serialize_scenario_outline(self, scenario: ScenarioOutline) -> str:
         """Serialize a ScenarioOutline with aligned examples."""
-        lines = []
-        lines.append(f"  Scenario Outline: {scenario.title}")
-        for step in scenario.steps:
-            lines.append(f"    {step}")
-
-        if scenario.examples:
+        def serialize_scenario_examples():
+            nonlocal lines, scenario
+            if not scenario:
+                return
             headers = self._extract_placeholders(scenario.steps)
 
             rows = [headers]
@@ -320,6 +343,13 @@ class FeatureArtefact(Artefact):
             for formatted_row in formatted_rows:
                 lines.append(f"      {formatted_row}")
 
+        lines = []
+        lines.append(f"  Scenario Outline: {scenario.title}")
+        for step in scenario.steps:
+            lines.append(f"    {step}")
+
+        serialize_scenario_examples()
+
         return "\n".join(lines)
 
     def _extract_placeholders(self, steps):

ara_cli/artefact_models/keyfeature_artefact_model.py

@@ -47,39 +47,36 @@ class KeyfeatureIntent(Intent):
 
     @classmethod
     def deserialize_from_lines(cls, lines: List[str], start_index: int = 0) -> 'KeyfeatureIntent':
-        in_order_to = None
-        as_a = None
-        i_want = None
-
-        in_order_to_prefix = "In order to "
-        as_a_prefix = "As a "
-        as_a_prefix_alt = "As an "
-        i_want_prefix = "I want "
+        prefixes = [
+            ("In order to ", "in_order_to"),
+            ("As a ", "as_a"),
+            ("As an ", "as_a"),
+            ("I want ", "i_want"),
+        ]
+        found = {"in_order_to": None, "as_a": None, "i_want": None}
+
+        def match_and_store(line):
+            for prefix, field in prefixes:
+                if line.startswith(prefix) and found[field] is None:
+                    found[field] = line[len(prefix):].strip()
+                    return
 
         index = start_index
-        while index < len(lines) and (not in_order_to or not as_a or not i_want):
-            line = lines[index]
-            if line.startswith(in_order_to_prefix) and not in_order_to:
-                in_order_to = line[len(in_order_to_prefix):].strip()
-            elif line.startswith(as_a_prefix) and not as_a:
-                as_a = line[len(as_a_prefix):].strip()
-            elif line.startswith(as_a_prefix_alt) and not as_a:
-                as_a = line[len(as_a_prefix_alt):].strip()
-            elif line.startswith(i_want_prefix) and not i_want:
-                i_want = line[len(i_want_prefix):].strip()
+        while index < len(lines) and any(v is None for v in found.values()):
+            match_and_store(lines[index])
             index += 1
 
-        if not in_order_to:
+        if not found["in_order_to"]:
             raise ValueError("Could not find 'In order to' line")
-        if not as_a:
+        if not found["as_a"]:
             raise ValueError("Could not find 'As a' line")
-        if not i_want:
+        if not found["i_want"]:
             raise ValueError("Could not find 'I want' line")
 
         return cls(
-            in_order_to=in_order_to,
-            as_a=as_a,
-            i_want=i_want
+            in_order_to=found["in_order_to"],
+            as_a=found["as_a"],
+            i_want=found["i_want"]
         )