ara-cli 0.1.9.50__py3-none-any.whl → 0.1.9.52__py3-none-any.whl

ara_cli/artefact_lister.py

@@ -1,8 +1,7 @@
 from ara_cli.file_classifier import FileClassifier
-from ara_cli.template_manager import DirectoryNavigator
 from ara_cli.artefact_reader import ArtefactReader
 from ara_cli.file_lister import list_files_in_directory
-from ara_cli.artefact import Artefact
+from ara_cli.artefact_models.artefact_model import Artefact
 from ara_cli.list_filter import ListFilter, filter_list
 from ara_cli.artefact_fuzzy_search import suggest_close_name_matches
 import os
@@ -13,16 +12,26 @@ class ArtefactLister:
         self.file_system = file_system or os
 
     @staticmethod
-    def artefact_content_retrieval(artefact):
-        return artefact.content
+    def artefact_content_retrieval(artefact: Artefact):
+        content = artefact.serialize()
+        return content
 
     @staticmethod
-    def artefact_path_retrieval(artefact):
+    def artefact_path_retrieval(artefact: Artefact):
         return artefact.file_path
 
     @staticmethod
-    def artefact_tags_retrieval(artefact):
-        return artefact.tags
+    def artefact_tags_retrieval(artefact: Artefact):
+        final_tags = []
+
+        if not artefact:
+            return []
+
+        final_tags.extend([f"user_{user}" for user in artefact.users])
+        final_tags.append(artefact.status)
+        final_tags.extend(artefact.tags)
+
+        return final_tags
 
     def filter_artefacts(self, classified_files: list, list_filter: ListFilter):
         filtered_list = filter_list(
@@ -40,17 +49,15 @@ class ArtefactLister:
         navigate_to_target=False,
         list_filter: ListFilter | None = None
     ):
-        # make sure this function is always called from the ara top level directory
-        navigator = DirectoryNavigator()
-        if navigate_to_target:
-            navigator.navigate_to_target()
+        artefact_list = ArtefactReader.read_artefacts(tags=tags)
+        artefact_list = self.filter_artefacts(artefact_list, list_filter)
 
+        filtered_artefact_list = {
+            key: [artefact for artefact in value if artefact is not None]
+            for key, value in artefact_list.items()
+        }
         file_classifier = FileClassifier(self.file_system)
-        classified_files = file_classifier.classify_files(tags=tags)
-
-        classified_files = self.filter_artefacts(classified_files, list_filter)
-
-        file_classifier.print_classified_files(classified_files)
+        file_classifier.print_classified_files(filtered_artefact_list)
 
     def list_branch(
         self,
@@ -59,21 +66,23 @@ class ArtefactLister:
         list_filter: ListFilter | None = None
     ):
         file_classifier = FileClassifier(os)
-
         classified_artefacts = file_classifier.classify_files()
-        all_artefact_names = [artefact.file_name for artefact in classified_artefacts.get(classifier, [])]
-        if artefact_name not in all_artefact_names:
-            suggest_close_name_matches(artefact_name, all_artefact_names)
-            return
+        artefact_info = classified_artefacts.get(classifier, [])
+        matching_artefact_info = [p for p in artefact_info if p["title"] == artefact_name]
+
+        if not matching_artefact_info:
+            suggest_close_name_matches(
+                artefact_name,
+                [info["title"] for info in artefact_info]
+            )
 
         artefacts_by_classifier = {classifier: []}
         ArtefactReader.step_through_value_chain(
             artefact_name=artefact_name,
             classifier=classifier,
-            artefacts_by_classifier=artefacts_by_classifier
+            artefacts_by_classifier=artefacts_by_classifier,
         )
         artefacts_by_classifier = self.filter_artefacts(artefacts_by_classifier, list_filter)
-
         file_classifier.print_classified_files(artefacts_by_classifier)
 
     def list_children(
@@ -83,22 +92,24 @@ class ArtefactLister:
         list_filter: ListFilter | None = None
     ):
         file_classifier = FileClassifier(os)
-
         classified_artefacts = file_classifier.classify_files()
-        all_artefact_names = [artefact.file_name for artefact in classified_artefacts.get(classifier, [])]
-        if artefact_name not in all_artefact_names:
-            suggest_close_name_matches(artefact_name, all_artefact_names)
-            return
+        artefact_info = classified_artefacts.get(classifier, [])
+        matching_artefact_info = [p for p in artefact_info if p["title"] == artefact_name]
+
+        if not matching_artefact_info:
+            suggest_close_name_matches(
+                artefact_name,
+                [info["title"] for info in artefact_info]
+            )
 
         child_artefacts = ArtefactReader.find_children(
-                artefact_name=artefact_name,
-                classifier=classifier
+            artefact_name=artefact_name,
+            classifier=classifier
         )
+
         child_artefacts = self.filter_artefacts(child_artefacts, list_filter)
 
-        file_classifier.print_classified_files(
-            files_by_classifier=child_artefacts
-        )
+        file_classifier.print_classified_files(child_artefacts)
 
     def list_data(
         self,
@@ -107,21 +118,19 @@ class ArtefactLister:
         list_filter: ListFilter | None = None
     ):
         file_classifier = FileClassifier(os)
+        classified_artefact_info = file_classifier.classify_files()
+        artefact_info_dict = classified_artefact_info.get(classifier, [])
 
-        classified_artefacts = file_classifier.classify_files()
-        all_artefact_names = [artefact.file_name for artefact in classified_artefacts.get(classifier, [])]
-        if artefact_name not in all_artefact_names:
-            suggest_close_name_matches(artefact_name, all_artefact_names)
-            return
-
-        content, file_path = ArtefactReader.read_artefact(
-            classifier=classifier,
-            artefact_name=artefact_name
-        )
+        matching_info = [info for info in artefact_info_dict if info["title"] == artefact_name]
 
-        artefact = Artefact.from_content(content)
-        file_path = next((classified_artefact.file_path for classified_artefact in classified_artefacts.get(classifier, []) if classified_artefact.name == artefact.name), artefact)
+        if not matching_info:
+            suggest_close_name_matches(
+                artefact_name,
+                [info["title"] for info in artefact_info_dict]
+            )
+            return
 
-        file_path = os.path.splitext(file_path)[0] + '.data'
-        if os.path.exists(file_path):
-            list_files_in_directory(file_path, list_filter)
+        artefact_info = matching_info[0]
+        data_dir = os.path.splitext(artefact_info["file_path"])[0] + '.data'
+        if os.path.exists(data_dir):
+            list_files_in_directory(data_dir, list_filter)

ara_cli/artefact_models/artefact_model.py

@@ -11,6 +11,14 @@ import string
 ALLOWED_STATUS_VALUES = ("to-do", "in-progress", "review", "done", "closed")
 
 
+def replace_space_with_underscore(input: string):
+    return input.replace(' ', '_')
+
+
+def replace_underscore_with_space(input: string):
+    return input.replace('_', ' ')
+
+
 class ArtefactType(str, Enum):
     vision = "vision"
     businessgoal = "businessgoal"
@@ -44,6 +52,12 @@ class Contribution(BaseModel):
         classifier = self.classifier
         rule = self.rule
 
+        if artefact_name:
+            artefact_name = replace_space_with_underscore(artefact_name)
+        if artefact_name and classifier:
+            artefact_name = artefact_name.removesuffix(f"_{classifier}")
+            artefact_name = artefact_name.removesuffix(f"_{classifier.capitalize()}")
+            self.artefact_name = artefact_name
         if not artefact_name or not classifier:
             self.artefact_name = None
             self.classifier = None
@@ -60,7 +74,7 @@ class Contribution(BaseModel):
             return value
         if ' ' in value:
             warnings.warn(message="artefact_name can not contain spaces. Replacing spaces with '_'")
-            value = value.replace(' ', '_')
+            value = replace_space_with_underscore(value)
         return value
 
     @field_validator('classifier', mode='after')
@@ -90,7 +104,7 @@ class Contribution(BaseModel):
             rule = rule_text
         parent_text_list = parent_text.split(' ')
         classifier = parent_text_list[-1].lower()
-        artefact_name = '_'.join(parent_text_list[:-1])
+        artefact_name = '_'.join([s for s in parent_text_list if s][:-1])
 
         return cls(
             artefact_name=artefact_name,
@@ -102,7 +116,7 @@ class Contribution(BaseModel):
         if not self.classifier or not self.artefact_name:
             return ""
         artefact_type = Classifier.get_artefact_title(self.classifier)
-        artefact_name = self.artefact_name.replace("_", " ")
+        artefact_name = replace_underscore_with_space(self.artefact_name)
         contribution = f"{artefact_name} {artefact_type}"
         if self.rule:
             contribution = f"{contribution} using rule {self.rule}"
@@ -136,6 +150,7 @@ class Artefact(BaseModel, ABC):
         "validate_assignment": True
     }
 
+    _file_path: Optional[str] = None
     artefact_type: ArtefactType = Field(
         ...,
         description=f"Artefact classifier (mandatory). Allowed classifiers are {', '.join(ArtefactType)}"
@@ -166,6 +181,13 @@ class Artefact(BaseModel, ABC):
         description="Optional further description to understand the artefact. It is strongly recommended to add a description to every artefact."
     )
 
+    @property
+    def file_path(self) -> str:
+        if self._file_path is not None:
+            return self._file_path
+        sub_dir = Classifier.get_sub_directory(self.artefact_type)
+        return f"{sub_dir}/{self.title}.{self.artefact_type}"
+
     @field_validator('artefact_type')
     def validate_artefact_type(cls, v):
         if not isinstance(v, ArtefactType):
@@ -199,9 +221,7 @@ class Artefact(BaseModel, ABC):
     def validate_title(cls, v):
         if not v.strip():
             raise ValueError("artefact_title must not be empty")
-        if ' ' in v:
-            warnings.warn(message="artefact_name can not contain spaces. Replacing spaces with '_'")
-            v = v.replace(' ', '_')
+        v = replace_space_with_underscore(v)
 
         letters = list(string.ascii_letters)
         digits = list(string.digits)
@@ -230,12 +250,6 @@ class Artefact(BaseModel, ABC):
     def _artefact_type(cls) -> ArtefactType:    # pragma: no cover
         pass
 
-    def file_location(self) -> str:
-        artefact_type = self.artefact_type
-        sub_directory = Classifier.get_sub_directory(artefact_type)
-        file_path = f"ara/{sub_directory}/{self.title}.{artefact_type}"
-        return file_path
-
     @classmethod
     def _deserialize_tags(cls, lines) -> (Dict[str, str], List[str]):
         assert len(lines) > 0, "Empty lines given, can't extract tags"
@@ -279,7 +293,7 @@ class Artefact(BaseModel, ABC):
             raise ValueError(
                 f"No title found in {cls._artefact_type()}. Expected '{title_prefix}' as start of the title in line '{title_line}'")
         title = title_line[len(title_prefix):].strip()
-        title = title.replace(' ', '_')
+        title = replace_space_with_underscore(title)
         return title, lines
 
     @classmethod
@@ -349,7 +363,7 @@ class Artefact(BaseModel, ABC):
         pass
 
     def _serialize_title(self) -> str:
-        title = self.title.replace('_', ' ')
+        title = replace_underscore_with_space(self.title)
         return f"{self._title_prefix()} {title}"
 
     def _serialize_tags(self) -> (Optional[str]):

ara_cli/artefact_models/feature_artefact_model.py

@@ -85,7 +85,7 @@ class Example(BaseModel):
     def from_row(cls, headers: List[str], row: List[str]) -> 'Example':
         if len(row) != len(headers):
             raise ValueError(
-                f"Row has {len(row)} cells, but expected {len(headers)}")
+                f"Row has {len(row)} cells, but expected {len(headers)}.\nFound row: {row}")
         values = {header: value.strip() for header, value in zip(headers, row)}
         return cls(values=values)
 
@@ -175,6 +175,7 @@ class ScenarioOutline(BaseModel):
     @classmethod
     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()
@@ -190,6 +191,8 @@ class ScenarioOutline(BaseModel):
             headers = [h.strip() for h in lines[idx].split('|') if h.strip()]
             idx += 1
             while idx < len(lines) and lines[idx].strip():
+                if lines[idx].strip().startswith("Scenario:") or lines[idx].strip().startswith("Scenario Outline:"):
+                    break
                 row = [cell.strip()
                        for cell in lines[idx].split('|') if cell.strip()]
                 example = Example.from_row(headers, row)

ara_cli/artefact_reader.py

@@ -1,8 +1,8 @@
-from ara_cli.directory_navigator import DirectoryNavigator
 from ara_cli.classifier import Classifier
 from ara_cli.file_classifier import FileClassifier
-from ara_cli.artefact import Artefact
-from ara_cli.artefact_fuzzy_search import suggest_close_name_matches, suggest_close_name_matches_for_parent
+from ara_cli.artefact_models.artefact_model import Artefact
+from ara_cli.artefact_fuzzy_search import suggest_close_name_matches_for_parent, suggest_close_name_matches
+from typing import Dict, List
 import os
 import re
 
@@ -10,31 +10,29 @@ import re
 class ArtefactReader:
     @staticmethod
     def read_artefact(artefact_name, classifier):
-        original_directory = os.getcwd()
-        navigator = DirectoryNavigator()
-        navigator.navigate_to_target()
-
         if not Classifier.is_valid_classifier(classifier):
             print("Invalid classifier provided. Please provide a valid classifier.")
-            os.chdir(original_directory)
             return None, None
 
-        sub_directory = Classifier.get_sub_directory(classifier)
-        file_path = os.path.join(sub_directory, f"{artefact_name}.{classifier}")
-
-        file_exists = os.path.exists(file_path)
-
-        if not file_exists:
-            print(f"File \"{file_path}\" not found")
-            os.chdir(original_directory)
-            return None, None
+        file_classifier = FileClassifier(os)
+        classified_file_info = file_classifier.classify_files()
+        artefact_info_of_classifier = classified_file_info.get(classifier, [])
 
-        with open(file_path, 'r') as file:
-            content = file.read()
+        for artefact_info in artefact_info_of_classifier:
+            file_path = artefact_info["file_path"]
+            artefact_title = artefact_info["title"]
+            if artefact_title == artefact_name:
+                with open(file_path, 'r') as file:
+                    content = file.read()
+                return content, artefact_info
 
-        os.chdir(original_directory)
+        all_artefact_names = [info["title"] for info in artefact_info_of_classifier]
+        suggest_close_name_matches(
+            artefact_name,
+            all_artefact_names
+        )
 
-        return content, file_path
+        return None, None
 
     @staticmethod
     def extract_parent_tree(artefact_content):
@@ -53,41 +51,77 @@ class ArtefactReader:
         return parent_name, parent_type
 
     @staticmethod
-    def find_children(artefact_name, classifier, artefacts_by_classifier={}, classified_artefacts=None):
+    def merge_dicts(dict1, dict2):
+        from collections import defaultdict
 
-        def merge_dicts(dict1, dict2):
-            from collections import defaultdict
+        merged = defaultdict(list)
+        for d in [dict1, dict2]:
+            for key, artefacts in d.items():
+                merged[key].extend(artefacts)
+        return dict(merged)
 
-            merged_dict = defaultdict(list)
+    @staticmethod
+    def read_artefacts(classified_artefacts=None, file_system=os, tags=None) -> Dict[str, List[Artefact]]:
+        from ara_cli.artefact_models.artefact_load import artefact_from_content
 
-            # Add items from the first dictionary
-            for key, artefact_list in dict1.items():
-                merged_dict[key].extend(artefact_list)
+        if classified_artefacts is None:
+            file_classifier = FileClassifier(file_system)
+            classified_artefacts = file_classifier.classify_files()
 
-            # Add items from the second dictionary
-            for key, artefact_list in dict2.items():
-                merged_dict[key].extend(artefact_list)
+        artefacts = {artefact_type: []
+                     for artefact_type in classified_artefacts.keys()}
+        for artefact_type, artefact_info_dicts in classified_artefacts.items():
+            for artefact_info in artefact_info_dicts:
+                try:
+                    with open(artefact_info["file_path"], 'r') as file:
+                        content = file.read()
+                    artefact = artefact_from_content(content)
+                    if not artefact:
+                        continue
+                    # Store the full file path in the artefact
+                    artefact._file_path = artefact_info["file_path"]
+                    artefacts[artefact_type].append(artefact)
+                    # else:
+                        # Include file path if deserialization fails
+                        # FIXME: LOOK INTO IT
+                        # artefacts[artefact_type].append(file_path)
+                except Exception:
+                    # TODO: catch only specific exceptions
+                    # TODO: implament error message for deserialization or "ara scan" or "ara autofix"
+                    # print(f"Warning: Could not deserialize artefact at {artefact_info}: {e}")
+                    # artefacts[artefact_type].append(file_path)
+                    continue
+        return artefacts
 
-            return dict(merged_dict)
+    @staticmethod
+    def find_children(artefact_name, classifier, artefacts_by_classifier={}, classified_artefacts=None):
+        artefacts_by_classifier = artefacts_by_classifier or {}
+        filtered_artefacts = {k: [] for k in artefacts_by_classifier.keys()}
 
         if classified_artefacts is None:
-            file_classifier = FileClassifier(os)
-            classified_artefacts = file_classifier.classify_files()
+            classified_artefacts = ArtefactReader.read_artefacts()
 
-        filtered_artefacts = {}
-        for key, artefact_list in classified_artefacts.items():
-            filtered_list = [
-                artefact for artefact in artefact_list
-                if artefact.parent and
-                artefact.parent.name == artefact_name and
-                artefact.parent.classifier == classifier
-            ]
-            if filtered_list:
-                filtered_artefacts[key] = filtered_list
+        for artefact_classifier, artefacts in classified_artefacts.items():
+            for artefact in artefacts:
+                if not isinstance(artefact, Artefact):
+                    continue
 
-        merged_dict = merge_dicts(artefacts_by_classifier, filtered_artefacts)
+                try:
+                    contribution = artefact.contribution
+                    if (contribution and
+                        contribution.artefact_name == artefact_name and
+                            contribution.classifier == classifier):
 
-        return merged_dict
+                        file_classifier = artefact._file_path.split('.')[-1]
+
+                        if file_classifier not in filtered_artefacts:
+                            filtered_artefacts[file_classifier] = []
+                        filtered_artefacts[file_classifier].append(artefact)
+
+                except AttributeError as e:
+                    continue
+
+        return ArtefactReader.merge_dicts(artefacts_by_classifier, filtered_artefacts)
 
     @staticmethod
     def step_through_value_chain(
@@ -95,34 +129,41 @@ class ArtefactReader:
             classifier,
             artefacts_by_classifier={},
             classified_artefacts: dict[str, list[Artefact]] | None = None
-            ):
-        if classified_artefacts is None:
-            file_classifier = FileClassifier(os)
-            classified_artefacts = file_classifier.classify_files()
-
-        content, file_path = ArtefactReader.read_artefact(artefact_name, classifier)
-
-        artefact = Artefact.from_content(content)
-        artefact_path = next((classified_artefact.file_path for classified_artefact in classified_artefacts.get(classifier, []) if classified_artefact.name == artefact.name), artefact.file_path)
-        artefact._file_path = artefact_path
+    ):
+        from ara_cli.artefact_models.artefact_load import artefact_from_content
 
+        if classified_artefacts is None:
+            classified_artefacts = ArtefactReader.read_artefacts()
 
         if classifier not in artefacts_by_classifier:
             artefacts_by_classifier[classifier] = []
 
-        matching_artefacts = list(filter(lambda x: x.name == artefact.name, artefacts_by_classifier[classifier]))
-        if len(matching_artefacts) != 0:
+        artefact = next(filter(
+            lambda x: x.title == artefact_name, classified_artefacts[classifier]
+        ))
+
+        if not artefact:
+            return
+        if artefact in artefacts_by_classifier[classifier]:
             return
 
         artefacts_by_classifier[classifier].append(artefact)
-        parent = artefact.parent
-        if parent:
-            parent_name = parent.name
+
+        parent = artefact.contribution
+        if parent and parent.artefact_name and parent.classifier:
+            parent_name = parent.artefact_name
             parent_classifier = parent.classifier
 
-            all_artefact_names = [artefact.file_name for artefact in classified_artefacts.get(parent_classifier, [])]
+            parent_classifier_artefacts = classified_artefacts[parent_classifier]
+            all_artefact_names = [x.title for x in parent_classifier_artefacts]
+
             if parent_name not in all_artefact_names:
-                suggest_close_name_matches_for_parent(artefact_name, all_artefact_names, parent_name)
+                if parent_name is not None:
+                    suggest_close_name_matches_for_parent(
+                        artefact_name,
+                        all_artefact_names,
+                        parent_name
+                    )
                 print()
                 return
 

ara_cli/artefact_renamer.py

@@ -12,16 +12,17 @@ class ArtefactRenamer:
         self.link_updater = ArtefactLinkUpdater()
 
     @lru_cache(maxsize=None)
-    def navigate_to_target(self):
+    def navigate_to_target(self) -> str:
         navigator = DirectoryNavigator()
-        navigator.navigate_to_target()
+        original_directory = navigator.navigate_to_target()
+        return original_directory
 
     @lru_cache(maxsize=None)
     def compile_pattern(self, pattern):
         return re.compile(pattern)
 
     def rename(self, old_name, new_name, classifier):
-        self.navigate_to_target()
+        original_directory = self.navigate_to_target()
 
         if not new_name:
             raise ValueError("New name must be provided for renaming.")
@@ -50,13 +51,10 @@ class ArtefactRenamer:
 
         # Perform the renaming of the file and directory
         self.file_system.rename(old_file_path, new_file_path)
+        print(f"Renamed file: {old_file_path} to {new_file_path}")
         if old_dir_exists:
             self.file_system.rename(old_dir_path, new_dir_path)
-        # TODO: we should be able to remove this next line once ara delete ignores non-existent data folders
-        os.makedirs(new_dir_path, exist_ok=True)
-
-        print(f"Renamed file: {old_file_path} to {new_file_path}")
-        print(f"Renamed directory: {old_dir_path} to {new_dir_path}")
+            print(f"Renamed directory: {old_dir_path} to {new_dir_path}")
 
         # Update the title within the artefact file
         self._update_title_in_artefact(new_file_path, new_name, classifier)
@@ -64,6 +62,8 @@ class ArtefactRenamer:
         # Update links in related artefact files
         self.link_updater.update_links_in_related_artefacts(old_name, new_name)
 
+        os.chdir(original_directory)
+
     def _update_title_in_artefact(self, artefact_path, new_title, classifier):
         # Format the new title: replace underscores with spaces
         formatted_new_title = new_title.replace('_', ' ')

ara_cli/artefact_scan.py

@@ -0,0 +1,46 @@
+def check_file(file_path, artefact_class):
+    from pydantic import ValidationError
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            content = f.read()
+    except OSError as e:
+        return False, f"File error: {e}"
+    try:
+        artefact_class.deserialize(content)
+        return True, None
+    except (ValidationError, ValueError, AssertionError) as e:
+        return False, str(e)
+    except Exception as e:
+        return False, f"Unexpected error: {e!r}"
+
+
+def find_invalid_files(classified_artefact_info, classifier):
+    from ara_cli.artefact_models.artefact_mapping import artefact_type_mapping
+
+    artefact_class = artefact_type_mapping[classifier]
+    invalid_files = []
+    for artefact_info in classified_artefact_info[classifier]:
+        if "templates/" in artefact_info["file_path"]:
+            continue
+        is_valid, reason = check_file(artefact_info["file_path"], artefact_class)
+        if not is_valid:
+            invalid_files.append((artefact_info["file_path"], reason))
+    return invalid_files
+
+
+def show_results(invalid_artefacts):
+    has_issues = False
+    with open("incompatible_artefacts_report.md", "w") as report:
+        report.write("# Artefact Check Report\n\n")
+        for classifier, files in invalid_artefacts.items():
+            if files:
+                has_issues = True
+                print(f"\nIncompatible {classifier} Files:")
+                report.write(f"## {classifier}\n")
+                for file, reason in files:
+                    print(f"\t- {file}")
+                    report.write(f"- `{file}`: {reason}\n")
+                report.write("\n")
+        if not has_issues:
+            print("All files are good!")
+            report.write("No problems found.\n")