ara-cli 0.1.10.5__py3-none-any.whl → 0.1.14.0__py3-none-any.whl

ara_cli/artefact_reader.py

@@ -3,20 +3,29 @@ from ara_cli.classifier import Classifier
 from ara_cli.file_classifier import FileClassifier
 from ara_cli.artefact_models.artefact_model import Artefact
 from ara_cli.artefact_models.artefact_load import artefact_from_content
-from ara_cli.artefact_fuzzy_search import suggest_close_name_matches_for_parent, suggest_close_name_matches
+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
 
 
 class ArtefactReader:
-    @staticmethod
-    def read_artefact_data(artefact_name, classifier, classified_file_info = None) -> tuple[str, dict[str, str]]:
+    def __init__(self, file_system=None):
+        self.file_system = file_system or os
+
+    def read_artefact_data(
+        self, artefact_name, classifier, classified_file_info=None
+    ) -> tuple[str, dict[str, str]]:
         if not Classifier.is_valid_classifier(classifier):
-            raise ValueError("Invalid classifier provided. Please provide a valid classifier.")
+            raise ValueError(
+                "Invalid classifier provided. Please provide a valid classifier."
+            )
 
         if not classified_file_info:
-            file_classifier = FileClassifier(os)
+            file_classifier = FileClassifier(self.file_system)
             classified_file_info = file_classifier.classify_files()
         artefact_info_of_classifier = classified_file_info.get(classifier, [])
 
@@ -24,21 +33,21 @@ class ArtefactReader:
             file_path = artefact_info["file_path"]
             artefact_title = artefact_info["title"]
             if artefact_title == artefact_name:
-                with open(file_path, 'r', encoding='utf-8') as file:
+                with open(file_path, "r", encoding="utf-8") as file:
                     content = file.read()
                 return content, artefact_info
 
         all_artefact_names = [info["title"] for info in artefact_info_of_classifier]
-        suggest_close_name_matches(
-            artefact_name,
-            all_artefact_names
-        )
+        suggest_close_name_matches(artefact_name, all_artefact_names)
 
         return None, None
 
-    @staticmethod
-    def read_artefact(artefact_name, classifier, classified_file_info=None) -> Artefact:
-        content, artefact_info = ArtefactReader.read_artefact_data(artefact_name, classifier, classified_file_info)
+    def read_artefact(
+        self, artefact_name, classifier, classified_file_info=None
+    ) -> Artefact:
+        content, artefact_info = self.read_artefact_data(
+            artefact_name, classifier, classified_file_info
+        )
         if not content or not artefact_info:
             return None
         file_path = artefact_info["file_path"]
@@ -49,9 +58,11 @@ class ArtefactReader:
     @staticmethod
     def extract_parent_tree(artefact_content):
         artefact_titles = Classifier.artefact_titles()
-        title_segment = '|'.join(artefact_titles)
+        title_segment = "|".join(artefact_titles)
 
-        regex_pattern = rf'(?:Contributes to|Illustrates)\s*:*\s*(.*)\s+({title_segment}).*'
+        regex_pattern = (
+            rf"(?:Contributes to|Illustrates)\s*:*\s*(.*)\s+({title_segment}).*"
+        )
         regex = re.compile(regex_pattern)
         match = re.search(regex, artefact_content)
         if not match:
@@ -72,33 +83,40 @@ class ArtefactReader:
                 merged[key].extend(artefacts)
         return dict(merged)
 
-    @staticmethod
-    def read_artefacts(classified_artefacts=None, file_system=os, tags=None) -> Dict[str, List[Artefact]]:
+    def read_artefacts(
+        self, classified_artefacts=None, tags=None
+    ) -> Dict[str, List[Artefact]]:
 
         if classified_artefacts is None:
-            file_classifier = FileClassifier(file_system)
+            file_classifier = FileClassifier(self.file_system)
             classified_artefacts = file_classifier.classify_files()
 
-        artefacts = {artefact_type: []
-                     for artefact_type in classified_artefacts.keys()}
+        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:
                 title = artefact_info["title"]
                 try:
-                    artefact = ArtefactReader.read_artefact(title, artefact_type, classified_artefacts)
+                    artefact = self.read_artefact(
+                        title, artefact_type, classified_artefacts
+                    )
                     artefacts[artefact_type].append(artefact)
                 except Exception as e:
                     error_handler.report_error(e, f"reading {artefact_type} '{title}'")
                     continue
         return artefacts
 
-    @staticmethod
-    def find_children(artefact_name, classifier, artefacts_by_classifier=None, classified_artefacts=None):
+    def find_children(
+        self,
+        artefact_name,
+        classifier,
+        artefacts_by_classifier=None,
+        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:
-            classified_artefacts = ArtefactReader.read_artefacts()
+            classified_artefacts = self.read_artefacts()
 
         for artefact_classifier, artefacts in classified_artefacts.items():
             for artefact in artefacts:
@@ -112,38 +130,37 @@ class ArtefactReader:
     def _process_artefact(artefact, artefact_name, classifier, filtered_artefacts):
         if not isinstance(artefact, Artefact):
             return
-        contribution = getattr(artefact, 'contribution', None)
+        contribution = getattr(artefact, "contribution", None)
         if not contribution:
             return
-        if getattr(contribution, 'artefact_name', None) != artefact_name:
+        if getattr(contribution, "artefact_name", None) != artefact_name:
             return
-        if getattr(contribution, 'classifier', None) != classifier:
+        if getattr(contribution, "classifier", None) != classifier:
             return
 
-        file_classifier = getattr(artefact, '_file_path', '').split('.')[-1]
+        file_classifier = getattr(artefact, "_file_path", "").split(".")[-1]
         if file_classifier not in filtered_artefacts:
             filtered_artefacts[file_classifier] = []
         filtered_artefacts[file_classifier].append(artefact)
 
-    @staticmethod
     def step_through_value_chain(
-            artefact_name,
-            classifier,
-            artefacts_by_classifier=None,
-            classified_artefacts: dict[str, list['Artefact']] | None = None
+        self,
+        artefact_name,
+        classifier,
+        artefacts_by_classifier=None,
+        classified_artefacts: dict[str, list["Artefact"]] | None = None,
     ):
         from ara_cli.artefact_models.artefact_load import artefact_from_content
 
         artefacts_by_classifier = artefacts_by_classifier or {}
 
         if classified_artefacts is None:
-            classified_artefacts = ArtefactReader.read_artefacts()
+            classified_artefacts = self.read_artefacts()
 
         ArtefactReader._ensure_classifier_key(classifier, artefacts_by_classifier)
 
         artefact = ArtefactReader._find_artefact_by_name(
-            artefact_name,
-            classified_artefacts.get(classifier, [])
+            artefact_name, classified_artefacts.get(classifier, [])
         )
 
         if not artefact or artefact in artefacts_by_classifier[classifier]:
@@ -151,7 +168,7 @@ class ArtefactReader:
 
         artefacts_by_classifier[classifier].append(artefact)
 
-        parent = getattr(artefact, 'contribution', None)
+        parent = getattr(artefact, "contribution", None)
         if not ArtefactReader._has_valid_parent(parent):
             return
 
@@ -168,11 +185,11 @@ class ArtefactReader:
             print()
             return
 
-        ArtefactReader.step_through_value_chain(
+        self.step_through_value_chain(
             artefact_name=parent_name,
             classifier=parent_classifier,
             artefacts_by_classifier=artefacts_by_classifier,
-            classified_artefacts=classified_artefacts
+            classified_artefacts=classified_artefacts,
         )
 
     @staticmethod
@@ -186,13 +203,15 @@ class ArtefactReader:
 
     @staticmethod
     def _has_valid_parent(parent):
-        return parent and getattr(parent, 'artefact_name', None) and getattr(parent, 'classifier', None)
+        return (
+            parent
+            and getattr(parent, "artefact_name", None)
+            and getattr(parent, "classifier", None)
+        )
 
     @staticmethod
     def _suggest_parent_name_match(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
+                artefact_name, all_artefact_names, parent_name
             )

ara_cli/artefact_scan.py

@@ -4,12 +4,16 @@ import os
 
 def is_contribution_valid(contribution, classified_artefact_info) -> bool:
     from ara_cli.artefact_fuzzy_search import extract_artefact_names_of_classifier
-    if not contribution or not contribution.artefact_name or not contribution.classifier:
+
+    if (
+        not contribution
+        or not contribution.artefact_name
+        or not contribution.classifier
+    ):
         return True
 
     all_artefact_names = extract_artefact_names_of_classifier(
-        classified_files=classified_artefact_info,
-        classifier=contribution.classifier
+        classified_files=classified_artefact_info, classifier=contribution.classifier
     )
     if contribution.artefact_name not in all_artefact_names:
         return False
@@ -19,12 +23,18 @@ def is_contribution_valid(contribution, classified_artefact_info) -> bool:
 def is_rule_valid(contribution, classified_artefact_info) -> bool:
     from ara_cli.artefact_reader import ArtefactReader
 
-    if not contribution or not contribution.artefact_name or not contribution.classifier:
+    if (
+        not contribution
+        or not contribution.artefact_name
+        or not contribution.classifier
+    ):
         return True
     rule = contribution.rule
     if not rule:
         return True
-    parent = ArtefactReader.read_artefact(contribution.artefact_name, contribution.classifier)
+    parent = ArtefactReader().read_artefact(
+        contribution.artefact_name, contribution.classifier
+    )
     if not parent:
         return True
     rules = parent.rules
@@ -33,20 +43,26 @@ def is_rule_valid(contribution, classified_artefact_info) -> bool:
     return True
 
 
-def check_contribution(contribution, classified_artefact_info, file_path) -> tuple[bool, str]:
+def check_contribution(
+    contribution, classified_artefact_info, file_path
+) -> tuple[bool, str]:
     if not contribution:
         return True, None
 
     if not is_contribution_valid(contribution, classified_artefact_info):
-        reason = (f"Invalid Contribution Reference: The contribution references "
-                  f"'{contribution.classifier}' artefact '{contribution.artefact_name}' "
-                  f"which does not exist.")
+        reason = (
+            f"Invalid Contribution Reference: The contribution references "
+            f"'{contribution.classifier}' artefact '{contribution.artefact_name}' "
+            f"which does not exist."
+        )
         return False, reason
 
     if not is_rule_valid(contribution, classified_artefact_info):
-        reason = (f"Rule Mismatch: The contribution references "
-                  f"rule '{contribution.rule}' which the parent "
-                  f"{contribution.classifier} '{contribution.artefact_name}' does not have.")
+        reason = (
+            f"Rule Mismatch: The contribution references "
+            f"rule '{contribution.rule}' which the parent "
+            f"{contribution.classifier} '{contribution.artefact_name}' does not have."
+        )
         return False, reason
     return True, None
 
@@ -73,13 +89,17 @@ def check_file(file_path, artefact_class, classified_artefact_info=None):
 
         # Check title and file name matching
         if artefact_instance.title != file_name_without_ext:
-            reason = (f"Filename-Title Mismatch: The file name '{file_name_without_ext}' "
-                      f"does not match the artefact title '{artefact_instance.title}'.")
+            reason = (
+                f"Filename-Title Mismatch: The file name '{file_name_without_ext}' "
+                f"does not match the artefact title '{artefact_instance.title}'."
+            )
             return False, reason
 
         contribution = artefact_instance.contribution
 
-        contribution_valid, reason = check_contribution(contribution, classified_artefact_info, file_path)
+        contribution_valid, reason = check_contribution(
+            contribution, classified_artefact_info, file_path
+        )
         if not contribution_valid:
             return False, reason
 
@@ -100,7 +120,9 @@ def find_invalid_files(classified_artefact_info, classifier):
             continue
         if ".data" in artefact_info["file_path"]:
             continue
-        is_valid, reason = check_file(artefact_info["file_path"], artefact_class, classified_artefact_info)
+        is_valid, reason = check_file(
+            artefact_info["file_path"], artefact_class, classified_artefact_info
+        )
         if not is_valid:
             invalid_files.append((artefact_info["file_path"], reason))
     return invalid_files
@@ -122,4 +144,4 @@ def show_results(invalid_artefacts):
                 report.write("\n")
         if not has_issues:
             print("All files are good!")
-            report.write("No problems found.\n")
+            report.write("No problems found.\n")