small improvements to logging, and logic. as well as rename release workflow

Author: djdanielsson

.github/workflows/python-publish.yml .github/workflows/publish-to-pypi.yml.github/workflows/python-publish.yml renamed to .github/workflows/publish-to-pypi.yml

@@ -6,7 +6,7 @@
 Supports multiple input methods and validates the generated specs.
 
 Generated by: claude-4-sonnet
-Version: 1.0.0
+Version: 1.0.1
 """
 
 import argparse
@@ -197,6 +197,24 @@ def log_error(self, message: str, role_prefix: bool = True):
         prefix = f"[{self.current_role}] " if role_prefix and self.current_role else ""
         print(f"{prefix}{message}")
 
+    def _safe_load_yaml_file(self, file_path: Path, description: str = "") -> Optional[Dict[str, Any]]:
+        """Safely load a YAML file with proper error handling"""
+        try:
+            with open(file_path, "r", encoding="utf-8") as f:
+                content = f.read()
+                if not content.strip():
+                    return {}
+                return yaml.safe_load(content)
+        except yaml.YAMLError as e:
+            self.log_error(f"Invalid YAML in {file_path}: {e}")
+            return None
+        except (OSError, IOError) as e:
+            self.log_error(f"Could not read {file_path}: {e}")
+            return None
+        except Exception as e:
+            self.log_verbose(f"Could not parse {file_path}: {e}")
+            return None
+
     def log_section(self, title: str):
         """Log a section header"""
         if self.verbosity >= 1:
@@ -765,15 +783,15 @@ def parse_task_file_includes(self, task_file_path: Path) -> Set[str]:
                 print(f"        No includes found in {task_file_path.name}")
 
         except UnicodeDecodeError as e:
-            print(f"Error: Could not decode task file {task_file_path}: {e}")
+            self.log_error(f"Could not decode task file {task_file_path}: {e}")
         except (OSError, IOError) as e:
-            print(f"Error: Could not read task file {task_file_path}: {e}")
+            self.log_error(f"Could not read task file {task_file_path}: {e}")
         except yaml.YAMLError as e:
-            print(f"Warning: YAML parsing error in {task_file_path}: {e}")
+            self.log_verbose(f"YAML parsing error in {task_file_path}: {e}")
         except re.error as e:
-            print(f"Error: Regex pattern error in {task_file_path}: {e}")
+            self.log_error(f"Regex pattern error in {task_file_path}: {e}")
         except Exception as e:
-            print(f"Warning: Could not parse task file {task_file_path}: {e}")
+            self.log_verbose(f"Could not parse task file {task_file_path}: {e}")
 
         return includes
 
@@ -829,49 +847,25 @@ def analyze_role_structure(self, role_path: str) -> Dict[str, Any]:
         # Analyze defaults/main.yml
         defaults_file = role_dir / "defaults" / "main.yml"
         if defaults_file.exists():
-            try:
-                with open(defaults_file, "r", encoding="utf-8") as f:
-                    content = f.read().strip()
-                    if content:  # Only try to parse if file has content
-                        defaults = yaml.safe_load(content)
-                        # Handle case where YAML file contains only comments or is empty
-                        analysis["defaults"] = (
-                            defaults if isinstance(defaults, dict) else {}
-                        )
-                    else:
-                        analysis["defaults"] = {}
-            except yaml.YAMLError as e:
-                print(f"Error: Invalid YAML in {defaults_file}: {e}")
-                analysis["defaults"] = {}
-            except (OSError, IOError) as e:
-                print(f"Error: Could not read {defaults_file}: {e}")
-                analysis["defaults"] = {}
-            except Exception as e:
-                print(f"Warning: Could not parse {defaults_file}: {e}")
+            defaults = self._safe_load_yaml_file(defaults_file)
+            if defaults is not None:
+                # Handle case where YAML file contains only comments or is empty
+                analysis["defaults"] = (
+                    defaults if isinstance(defaults, dict) else {}
+                )
+            else:
                 analysis["defaults"] = {}
 
         # Analyze vars/main.yml
         vars_file = role_dir / "vars" / "main.yml"
         if vars_file.exists():
-            try:
-                with open(vars_file, "r", encoding="utf-8") as f:
-                    content = f.read().strip()
-                    if content:  # Only try to parse if file has content
-                        vars_data = yaml.safe_load(content)
-                        # Handle case where YAML file contains only comments or is empty
-                        analysis["vars"] = (
-                            vars_data if isinstance(vars_data, dict) else {}
-                        )
-                    else:
-                        analysis["vars"] = {}
-            except yaml.YAMLError as e:
-                print(f"Error: Invalid YAML in {vars_file}: {e}")
-                analysis["vars"] = {}
-            except (OSError, IOError) as e:
-                print(f"Error: Could not read {vars_file}: {e}")
-                analysis["vars"] = {}
-            except Exception as e:
-                print(f"Warning: Could not parse {vars_file}: {e}")
+            vars_data = self._safe_load_yaml_file(vars_file)
+            if vars_data is not None:
+                # Handle case where YAML file contains only comments or is empty
+                analysis["vars"] = (
+                    vars_data if isinstance(vars_data, dict) else {}
+                )
+            else:
                 analysis["vars"] = {}
 
         # Analyze meta/main.yml for author information
@@ -887,8 +881,8 @@ def analyze_role_structure(self, role_path: str) -> Dict[str, Any]:
                             authors = self._extract_authors_from_meta(meta_data)
                             analysis["authors"] = authors
                             if authors:
-                                print(
-                                    f"  Found {len(authors)} author(s): {', '.join(authors)}"
+                                self.log_verbose(
+                                    f"Found {len(authors)} author(s): {', '.join(authors)}"
                                 )
 
                             # Extract description information
@@ -904,23 +898,23 @@ def analyze_role_structure(self, role_path: str) -> Dict[str, Any]:
                             if descriptions.get("description") or descriptions.get(
                                 "short_description"
                             ):
-                                print(f"  Found description from meta/main.yml")
+                                self.log_verbose(f"Found description from meta/main.yml")
                     else:
                         analysis["authors"] = []
                         analysis["meta_description"] = []
                         analysis["meta_short_description"] = ""
             except yaml.YAMLError as e:
-                print(f"Warning: Invalid YAML in {meta_file}: {e}")
+                self.log_verbose(f"Invalid YAML in {meta_file}: {e}")
                 analysis["authors"] = []
                 analysis["meta_description"] = []
                 analysis["meta_short_description"] = ""
             except (OSError, IOError) as e:
-                print(f"Warning: Could not read {meta_file}: {e}")
+                self.log_verbose(f"Could not read {meta_file}: {e}")
                 analysis["authors"] = []
                 analysis["meta_description"] = []
                 analysis["meta_short_description"] = ""
             except Exception as e:
-                print(f"Warning: Could not parse {meta_file}: {e}")
+                self.log_verbose(f"Could not parse {meta_file}: {e}")
                 analysis["authors"] = []
                 analysis["meta_description"] = []
                 analysis["meta_short_description"] = ""
@@ -1012,7 +1006,7 @@ def _detect_version_info(self, role_dir: Path) -> Dict[str, Any]:
                             version_info["source"] = "collection"
                             return version_info
             except Exception as e:
-                print(f"  Warning: Could not parse galaxy.yml: {e}")
+                self.log_verbose(f"Could not parse galaxy.yml: {e}")
 
         # Not in a collection or no collection version found, check role version
         meta_file = role_dir / "meta" / "main.yml"
@@ -1038,7 +1032,7 @@ def _detect_version_info(self, role_dir: Path) -> Dict[str, Any]:
                                     version_info["source"] = "role"
                                     return version_info
             except Exception as e:
-                print(f"  Warning: Could not parse meta/main.yml for version: {e}")
+                self.log_verbose(f"Could not parse meta/main.yml for version: {e}")
 
         return version_info
 
@@ -1814,25 +1808,13 @@ def ignore_aliases(self, data):
                 # Disable YAML references/anchors (like *id001) for cleaner output
                 return True
 
-            def generate_anchor(self, node):
-                # Prevent anchor generation entirely
-                return None
-
             def ignore_aliases(self, data):
                 # Disable YAML references/anchors (like *id001) for cleaner output
                 return True
 
-            def generate_anchor(self, node):
-                # Prevent anchor generation entirely
-                return None
-
-        # Deep copy the specs to avoid any shared object references that could create anchors
-        import copy
-        specs_copy = copy.deepcopy(specs)
-
         # Configure YAML output for better readability
         yaml_content = yaml.dump(
-            specs_copy,
+            specs,
             Dumper=CustomDumper,
             default_flow_style=False,
             sort_keys=False,
@@ -2507,24 +2489,24 @@ def validate_specs(self) -> bool:
         valid = True
 
         for entry_name, entry_point in self.entry_points.items():
-            print(f"Validating entry point: {entry_name}")
+            self.log_info(f"Validating entry point: {entry_name}")
 
             # Check for required fields
             if not entry_point.short_description:
-                print(f"  Warning: No short_description for {entry_name}")
+                self.log_verbose(f"No short_description for {entry_name}")
 
             # Validate argument types
             for arg_name, arg_spec in entry_point.options.items():
                 if arg_spec.type not in [t.value for t in ArgumentType]:
-                    print(
-                        f"  Error: Invalid type '{arg_spec.type}' for argument '{arg_name}'"
+                    self.log_error(
+                        f"Invalid type '{arg_spec.type}' for argument '{arg_name}'"
                     )
                     valid = False
 
                 # Check list/dict element types
                 if arg_spec.type in ["list", "dict"] and not arg_spec.elements:
-                    print(
-                        f"  Warning: No elements type specified for {arg_spec.type} argument '{arg_name}'"
+                    self.log_verbose(
+                        f"No elements type specified for {arg_spec.type} argument '{arg_name}'"
                     )
 
             # Validate conditionals reference existing arguments
@@ -2548,23 +2530,23 @@ def validate_specs(self) -> bool:
                             )
 
                             if param not in all_args:
-                                print(
-                                    f"  Error: {condition_type} references unknown argument '{param}'"
+                                self.log_error(
+                                    f"{condition_type} references unknown argument '{param}'"
                                 )
                                 valid = False
 
                             for req_param in required_params:
                                 if req_param not in all_args:
-                                    print(
-                                        f"  Error: {condition_type} references unknown argument '{req_param}'"
+                                    self.log_error(
+                                        f"{condition_type} references unknown argument '{req_param}'"
                                     )
                                     valid = False
                     else:
                         # Format: [param1, param2, ...]
                         for param in condition:
                             if param not in all_args:
-                                print(
-                                    f"  Error: {condition_type} references unknown argument '{param}'"
+                                self.log_error(
+                                    f"{condition_type} references unknown argument '{param}'"
                                 )
                                 valid = False
 
@@ -2596,17 +2578,9 @@ def ignore_aliases(self, data):
                 # Disable YAML references/anchors (like *id001) for cleaner output
                 return True
 
-            def generate_anchor(self, node):
-                # Prevent anchor generation entirely
-                return None
-
-        # Deep copy the specs to avoid any shared object references that could create anchors
-        import copy
-        specs_copy = copy.deepcopy(specs)
-
         # Configure YAML output for better readability
         yaml_content = yaml.dump(
-            specs_copy,
+            specs,
             Dumper=CustomDumper,
             default_flow_style=False,
             sort_keys=False,
@@ -2684,12 +2658,8 @@ def create_example_config():
         }
     }
 
-    # Deep copy to avoid any shared references
-    import copy
-    config_copy = copy.deepcopy(example_config)
-
     yaml_content = yaml.dump(
-        config_copy, default_flow_style=False, sort_keys=False, indent=2
+        example_config, default_flow_style=False, sort_keys=False, indent=2
     )
 
     # Remove any YAML anchor/reference lines that may have slipped through