* refactoring

* additional tests

Author: acorderob

ppp.py

@@ -441,18 +441,18 @@ def __processprompts(self, prompt, negative_prompt):
         negative_prompt = self.__add_to_insertion_points(
             negative_prompt, p_processor.add_at["insertion_point"], n_processor.insertion_at
         )
-        if len(p_processor.add_at["start"]) > 0:
+        if p_processor.add_at["start"]:
             negative_prompt = self.__add_to_start(negative_prompt, p_processor.add_at["start"])
-        if len(p_processor.add_at["end"]) > 0:
+        if p_processor.add_at["end"]:
             negative_prompt = self.__add_to_end(negative_prompt, p_processor.add_at["end"])
 
         # Clean up
         prompt = self.__cleanup(prompt)
         negative_prompt = self.__cleanup(negative_prompt)
 
         # Check for wildcards not processed
-        foundP = len(p_processor.detectedWildcards) > 0
-        foundNP = len(n_processor.detectedWildcards) > 0
+        foundP = bool(p_processor.detectedWildcards)
+        foundNP = bool(n_processor.detectedWildcards)
         if foundP or foundNP:
             if self.wil_ifwildcards == self.IFWILDCARDS_CHOICES.stop:
                 self.logger.error("Found unprocessed wildcards!")
@@ -473,10 +473,11 @@ def __processprompts(self, prompt, negative_prompt):
                 if foundNP:
                     negative_prompt = self.WILDCARD_STOP.format(npwl) + negative_prompt
                 self.interrupt()
+
         # Check for special character sequences that should not be in the result
         compound_prompt = prompt + "\n" + negative_prompt
         found_sequences = re.findall(r"::|\$\$|\$\{|[{}]", compound_prompt)
-        if len(found_sequences) > 0:
+        if found_sequences:
             self.logger.warning(
                 f"""Found probably invalid character sequences on the result ({', '.join(map(lambda x: '"' + x + '"', set(found_sequences)))}). Something might be wrong!"""
             )
@@ -1255,15 +1256,13 @@ def __get_choices_internal(
                             break
                     if passes:
                         filtered_choice_values.append(c)
-                if len(filtered_choice_values) == 0:
+                if not filtered_choice_values:
                     self.__ppp.logger.warning(
                         f"Wildcard filter specifier '{','.join(['+'.join(y for y in x) for x in filter_specifier])}' found no matches in choices for wildcard '{wildcard_key}'!"
                     )
             else:
                 filtered_choice_values = choice_values.copy()
-            if len(filtered_choice_values) == 0:
-                num_choices = 0
-            else:
+            if filtered_choice_values:
                 if from_value < 0:
                     from_value = 1
                 elif from_value > len(filtered_choice_values):
@@ -1277,6 +1276,8 @@ def __get_choices_internal(
                     if from_value < to_value
                     else from_value
                 )
+            else:
+                num_choices = 0
             if num_choices < 2:
                 repeating = False
             if self.__ppp.debug_level == DEBUG_LEVEL.full:
@@ -1541,7 +1542,7 @@ def wildcard(self, tree: lark.Tree):
                 if self.__ppp.debug_level == DEBUG_LEVEL.full:
                     self.__ppp.logger.debug(f"Processing wildcard: {wildcard_key}")
                 selected_wildcards = self.__ppp.wildcard_obj.get_wildcards(wildcard_key)
-                if len(selected_wildcards) == 0:
+                if not selected_wildcards:
                     self.detectedWildcards.append(wc)
                     self.result += wc
                     t2 = time.time()

ppp_wildcards.py

@@ -82,11 +82,7 @@ def __hash__(self) -> int:
         return hash(deep_freeze(self.wildcards))
 
     def __sizeof__(self):
-        return (
-            self.wildcards.__sizeof__()
-            + self.__wildcards_folders.__sizeof__()
-            + self.__wildcard_files.__sizeof__()
-        )
+        return self.wildcards.__sizeof__() + self.__wildcards_folders.__sizeof__() + self.__wildcard_files.__sizeof__()
 
     def refresh_wildcards(self, debug_level: DEBUG_LEVEL, wildcards_folders: Optional[list[str]]):
         """
@@ -245,51 +241,60 @@ def __get_choices(self, obj: object, full_path: str, key_parts: list[str]) -> li
         Returns:
             list: list of choices
         """
-        choices = None
-        if obj is not None:
-            if isinstance(obj, (str, dict)):
-                choices = [obj]
-            elif isinstance(obj, (int, float, bool)):
-                choices = [str(obj)]
-            elif isinstance(obj, list) and len(obj) > 0:
-                choices = []
-                for i, c in enumerate(obj):
-                    invalid_choice = False
-                    if isinstance(c, str):
-                        choice = c
-                    elif isinstance(c, (int, float, bool)):
-                        choice = str(c)
-                    elif isinstance(c, list):
-                        # we create an anonymous wildcard
-                        choice = self.__create_anonymous_wildcard(full_path, key_parts, i, c)
-                    elif isinstance(c, dict):
-                        if self.is_dict_choices_options(c) or self.is_dict_choice_options(c):
-                            # we assume it is a choice or wildcard parameters in object format
-                            choice = c
-                            choice_content = choice.get("content", choice.get("text", None))
-                            if choice_content is not None and isinstance(choice_content, list):
-                                # we create an anonymous wildcard
-                                choice["content"] = self.__create_anonymous_wildcard(
-                                    full_path, key_parts, i, choice_content
-                                )
-                                if "text" in choice:
-                                    del choice["text"]
-                        elif len(c) == 1:
-                            # we assume it is an anonymous wildcard with options
-                            firstkey = list(c.keys())[0]
-                            choice = self.__create_anonymous_wildcard(full_path, key_parts, i, c[firstkey], firstkey)
-                        else:
-                            invalid_choice = True
-                    else:
-                        invalid_choice = True
-                    if invalid_choice:
-                        self.__logger.warning(
-                            f"Invalid choice {i+1} in wildcard '{'/'.join(key_parts)}' in file '{full_path}'!"
-                        )
-                    else:
-                        choices.append(choice)
+        if obj is None:
+            return None
+        if isinstance(obj, (str, dict)):
+            return [obj]
+        if isinstance(obj, (int, float, bool)):
+            return [str(obj)]
+        if not isinstance(obj, list) or len(obj) == 0:
+            self.__logger.warning(f"Invalid format in wildcard '{'/'.join(key_parts)}' in file '{full_path}'!")
+            return None
+        choices = []
+        for i, c in enumerate(obj):
+            if isinstance(c, (str, int, float, bool)):
+                choices.append(str(c))
+            elif isinstance(c, list):
+                # we create an anonymous wildcard
+                choices.append(self.__create_anonymous_wildcard(full_path, key_parts, i, c))
+            elif isinstance(c, dict):
+                choices.append(self.__process_dict_choice(c, full_path, key_parts, i))
+            else:
+                self.__logger.warning(
+                    f"Invalid choice {i+1} in wildcard '{'/'.join(key_parts)}' in file '{full_path}'!"
+                )
         return choices
 
+    def __process_dict_choice(self, c: dict, full_path: str, key_parts: list[str], i: int) -> dict:
+        """
+        Process a dictionary choice.
+
+        Args:
+            c (dict): The dictionary choice.
+            full_path (str): The path to the file.
+            key_parts (list[str]): The parts of the key.
+            i (int): The index of the choice.
+
+        Returns:
+            dict: The processed choice.
+        """
+        if self.is_dict_choices_options(c) or self.is_dict_choice_options(c):
+            # we assume it is a choice or wildcard parameters in object format
+            choice = c
+            choice_content = choice.get("content", choice.get("text", None))
+            if choice_content is not None and isinstance(choice_content, list):
+                # we create an anonymous wildcard
+                choice["content"] = self.__create_anonymous_wildcard(full_path, key_parts, i, choice_content)
+                if "text" in choice:
+                    del choice["text"]
+            return choice
+        if len(c) == 1:
+            # we assume it is an anonymous wildcard with options
+            firstkey = list(c.keys())[0]
+            return self.__create_anonymous_wildcard(full_path, key_parts, i, c[firstkey], firstkey)
+        self.__logger.warning(f"Invalid choice {i+1} in wildcard '{'/'.join(key_parts)}' in file '{full_path}'!")
+        return None
+
     def __create_anonymous_wildcard(self, full_path, key_parts, i, content, options=None):
         """
         Create an anonymous wildcard.

tests/tests.py

@@ -722,6 +722,20 @@ def test_wc_wildcard2_yaml(self):  # simple yaml wildcard with default options
             ppp=self.__nocupppp,
         )
 
+    def test_wc_test2_yaml(self):  # simple yaml wildcard
+        self.__process(
+            PromptPair("the choice is: __testwc/test2__", ""),
+            PromptPair("the choice is: 2", ""),
+            ppp=self.__nocupppp,
+        )
+
+    def test_wc_test3_yaml(self):  # simple yaml wildcard
+        self.__process(
+            PromptPair("the choice is: __testwc/test3__", ""),
+            PromptPair("the choice is: one choice", ""),
+            ppp=self.__nocupppp,
+        )
+
     def test_wc_wildcard_filter_index(self):  # wildcard with positional index filter
         self.__process(
             PromptPair("the choice is: __yaml/wildcard2'2'__", ""),