amd-node-scraper 0.0.1__py3-none-any.whl

nodescraper/plugins/inband/os/analyzer_args.py

@@ -0,0 +1,64 @@
+###############################################################################
+#
+# MIT License
+#
+# Copyright (c) 2025 Advanced Micro Devices, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+###############################################################################
+from typing import Union
+
+from pydantic import Field, field_validator
+
+from nodescraper.models import AnalyzerArgs
+from nodescraper.plugins.inband.os.osdata import OsDataModel
+
+
+class OsAnalyzerArgs(AnalyzerArgs):
+    exp_os: Union[str, list] = Field(default_factory=list)
+    exact_match: bool = True
+
+    @field_validator("exp_os", mode="before")
+    @classmethod
+    def validate_exp_os(cls, exp_os: Union[str, list]) -> list:
+        """support str or list input for exp_os
+
+        Args:
+            exp_os (Union[str, list]): exp_os input
+
+        Returns:
+            list: exp_os list
+        """
+        if isinstance(exp_os, str):
+            exp_os = [exp_os]
+
+        return exp_os
+
+    @classmethod
+    def build_from_model(cls, datamodel: OsDataModel) -> "OsAnalyzerArgs":
+        """build analyzer args from data model
+
+        Args:
+            datamodel (OsDataModel): data model for plugin
+
+        Returns:
+            OsAnalyzerArgs: instance of analyzer args class
+        """
+        return cls(exp_os=datamodel.os_name, exact_match=True)

nodescraper/plugins/inband/os/os_analyzer.py

@@ -0,0 +1,73 @@
+###############################################################################
+#
+# MIT License
+#
+# Copyright (c) 2025 Advanced Micro Devices, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+###############################################################################
+from typing import Optional
+
+from nodescraper.enums import EventCategory, EventPriority, ExecutionStatus
+from nodescraper.interfaces import DataAnalyzer
+from nodescraper.models import TaskResult
+
+from .analyzer_args import OsAnalyzerArgs
+from .osdata import OsDataModel
+
+
+class OsAnalyzer(DataAnalyzer[OsDataModel, OsAnalyzerArgs]):
+    """Check os matches expected versions"""
+
+    DATA_MODEL = OsDataModel
+
+    def analyze_data(self, data: OsDataModel, args: Optional[OsAnalyzerArgs] = None) -> TaskResult:
+        """Analyze the OS data against expected OS names.
+
+        Args:
+            data (OsDataModel): Operating System data to analyze.
+            args (Optional[OsAnalyzerArgs], optional): OS analysis arguments. Defaults to None.
+
+        Returns:
+            TaskResult: Result of the analysis containing status and message.
+        """
+        if not args or not args.exp_os:
+            self.result.message = "Expected OS name not provided"
+            self.result.status = ExecutionStatus.NOT_RAN
+            return self.result
+
+        for os_name in args.exp_os:
+            if (os_name == data.os_name and args.exact_match) or (
+                os_name in data.os_name and not args.exact_match
+            ):
+                self.result.message = "OS name matches expected"
+                self.result.status = ExecutionStatus.OK
+                return self.result
+
+        self.result.message = f"OS name mismatch! Expected: {args.exp_os}, actual: {data.os_name}"
+        self.result.status = ExecutionStatus.ERROR
+        self._log_event(
+            category=EventCategory.OS,
+            description=f"{self.result.message}",
+            data={"expected": args.exp_os, "actual": data.os_name},
+            priority=EventPriority.CRITICAL,
+            console_log=True,
+        )
+        return self.result

nodescraper/plugins/inband/os/os_collector.py

@@ -0,0 +1,131 @@
+###############################################################################
+#
+# MIT License
+#
+# Copyright (c) 2025 Advanced Micro Devices, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+###############################################################################
+import re
+from typing import Optional
+
+from nodescraper.base import InBandDataCollector
+from nodescraper.enums import EventCategory, EventPriority, ExecutionStatus, OSFamily
+from nodescraper.models import TaskResult
+
+from .osdata import OsDataModel
+
+
+class OsCollector(InBandDataCollector[OsDataModel, None]):
+    """Collect OS details"""
+
+    DATA_MODEL = OsDataModel
+    CMD_VERSION_WINDOWS = "wmic os get Version /value"
+    CMD_VERSION = "cat /etc/*release | grep VERSION_ID"
+    CMD_WINDOWS = "wmic os get Caption /Value"
+    PRETTY_STR = "PRETTY_NAME"  # noqa: N806
+    CMD = f"sh -c '( lsb_release -ds || (cat /etc/*release | grep {PRETTY_STR}) || uname -om ) 2>/dev/null | head -n1'"
+
+    def collect_version(self) -> str:
+        """Collect OS version.
+
+        Returns:
+            str: OS version string, empty string if not found.
+        """
+        if self.system_info.os_family == OSFamily.WINDOWS:
+            res = self._run_sut_cmd(self.CMD_VERSION_WINDOWS)
+            if res.exit_code == 0:
+                os_version = re.search(r"Version=([\w\s\.]+)", res.stdout).group(1)
+            else:
+                self._log_event(
+                    category=EventCategory.OS,
+                    description="OS version not found",
+                    priority=EventPriority.ERROR,
+                )
+                os_version = ""
+        else:
+            res = self._run_sut_cmd(self.CMD_VERSION)
+            if res.exit_code == 0:
+                os_version = res.stdout
+                os_version = os_version.removeprefix("VERSION_ID=")
+                os_version = os_version.strip('" ')
+            else:
+                self._log_event(
+                    category=EventCategory.OS,
+                    description="OS version not found",
+                    priority=EventPriority.ERROR,
+                )
+                os_version = ""
+        return os_version
+
+    def collect_data(self, args=None) -> tuple[TaskResult, Optional[OsDataModel]]:
+        """Collect OS name and version.
+
+        Returns:
+            tuple[TaskResult, Optional[OsDataModel]]: tuple containing the task result and OS data model or None if not found.
+        """
+        os_name = None
+        if self.system_info.os_family == OSFamily.WINDOWS:
+            res = self._run_sut_cmd(self.CMD_WINDOWS)
+            if res.exit_code == 0:
+                os_name = re.search(r"Caption=([\w\s]+)", res.stdout).group(1)
+        else:
+            res = self._run_sut_cmd(self.CMD)
+            # search for PRETTY_NAME in res
+            if res.exit_code == 0:
+                if res.stdout.find(self.PRETTY_STR) != -1:
+                    os_name = res.stdout
+                    os_name = os_name.removeprefix(f"{self.PRETTY_STR}=")
+                    # remove the ending/starting quotes and spaces
+                    os_name = os_name.strip('" ')
+                else:
+                    os_name = res.stdout
+            else:
+                self._log_event(
+                    category=EventCategory.OS,
+                    description="OS name not found",
+                    priority=EventPriority.ERROR,
+                )
+
+        if os_name:
+            os_version = self.collect_version()
+            os_data = OsDataModel(
+                os_name=os_name,
+                os_version=os_version,
+            )
+            self._log_event(
+                category="OS_NAME_READ",
+                description="OS name data collected",
+                data=os_data.model_dump(),
+                priority=EventPriority.INFO,
+            )
+            self.result.message = f"OS: {os_name}"
+            self.result.status = ExecutionStatus.OK
+        else:
+            os_data = None
+            self._log_event(
+                category=EventCategory.OS,
+                description="OS name not found",
+                priority=EventPriority.CRITICAL,
+            )
+            self.result.message = "OS name not found"
+            self.result.status = ExecutionStatus.EXECUTION_FAILURE
+
+        return self.result, os_data

nodescraper/plugins/inband/os/os_plugin.py

@@ -0,0 +1,43 @@
+###############################################################################
+#
+# MIT License
+#
+# Copyright (c) 2025 Advanced Micro Devices, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+###############################################################################
+from nodescraper.base import InBandDataPlugin
+
+from .analyzer_args import OsAnalyzerArgs
+from .os_analyzer import OsAnalyzer
+from .os_collector import OsCollector
+from .osdata import OsDataModel
+
+
+class OsPlugin(InBandDataPlugin[OsDataModel, None, OsAnalyzerArgs]):
+    """Plugin for collection and analysis of os version data"""
+
+    DATA_MODEL = OsDataModel
+
+    COLLECTOR = OsCollector
+
+    ANALYZER = OsAnalyzer
+
+    ANALYZER_ARGS = OsAnalyzerArgs

nodescraper/plugins/inband/os/osdata.py

@@ -0,0 +1,31 @@
+###############################################################################
+#
+# MIT License
+#
+# Copyright (c) 2025 Advanced Micro Devices, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+###############################################################################
+from nodescraper.models import DataModel
+
+
+class OsDataModel(DataModel):
+    os_name: str
+    os_version: str = ""

nodescraper/plugins/inband/package/__init__.py

@@ -0,0 +1,25 @@
+###############################################################################
+#
+# MIT License
+#
+# Copyright (c) 2025 Advanced Micro Devices, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+###############################################################################

nodescraper/plugins/inband/package/analyzer_args.py

@@ -0,0 +1,48 @@
+###############################################################################
+#
+# MIT License
+#
+# Copyright (c) 2025 Advanced Micro Devices, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+###############################################################################
+from typing import Dict, Optional
+
+from pydantic import Field
+
+from nodescraper.models import AnalyzerArgs
+from nodescraper.plugins.inband.package.packagedata import PackageDataModel
+
+
+class PackageAnalyzerArgs(AnalyzerArgs):
+    exp_package_ver: Dict[str, Optional[str]] = Field(default_factory=dict)
+    regex_match: bool = False
+    # rocm_regex is optional and should be specified in plugin_config.json if needed
+    rocm_regex: Optional[str] = None
+    enable_rocm_regex: bool = False
+
+    @classmethod
+    def build_from_model(cls, datamodel: PackageDataModel) -> "PackageAnalyzerArgs":
+        # Use custom rocm_regex from collection_args if enable_rocm_regex is true
+        rocm_regex = None
+        if datamodel.enable_rocm_regex and datamodel.rocm_regex:
+            rocm_regex = datamodel.rocm_regex
+
+        return cls(exp_package_ver=datamodel.version_info, rocm_regex=rocm_regex)

nodescraper/plugins/inband/package/package_analyzer.py

@@ -0,0 +1,253 @@
+###############################################################################
+#
+# MIT License
+#
+# Copyright (c) 2025 Advanced Micro Devices, Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+###############################################################################
+import re
+from typing import Optional, Pattern
+
+from nodescraper.enums import EventCategory, EventPriority, ExecutionStatus
+from nodescraper.interfaces import DataAnalyzer
+from nodescraper.models import TaskResult
+
+from .analyzer_args import PackageAnalyzerArgs
+from .packagedata import PackageDataModel
+
+
+class PackageAnalyzer(DataAnalyzer[PackageDataModel, PackageAnalyzerArgs]):
+    """Check the package version data against the expected package version data"""
+
+    DATA_MODEL = PackageDataModel
+
+    def regex_version_data(
+        self,
+        package_data: dict[str, str],
+        key_search: re.Pattern[str],
+        value_search: Optional[Pattern[str]],
+    ) -> tuple[bool, list[tuple[str, str, str]]]:
+        """Searches the package values for the key and value search patterns
+
+        Args:
+            package_data (dict[str, str]): a dictionary of package names and versions
+            key_search (re.Pattern[str]): a compiled regex pattern to search for the package name
+            value_search (Optional[Pattern[str]]): a compiled regex pattern to search for the package version, if None then any version is accepted
+
+        Returns:
+            tuple: (value_found, version_mismatches) where value_found is a bool and
+                   version_mismatches is a list of (package_name, expected_pattern, found_version) tuples
+        """
+
+        value_found = False
+        version_mismatches = []
+        for name, version in package_data.items():
+            self.logger.debug("Package data: %s, %s", name, version)
+            key_search_res = key_search.search(name)
+            if key_search_res:
+                value_found = True
+                if value_search is None:
+                    continue
+                value_search_res = value_search.search(version)
+                if not value_search_res:
+                    version_mismatches.append((name, value_search.pattern, version))
+                    self._log_event(
+                        EventCategory.APPLICATION,
+                        f"Package {key_search.pattern} Version Mismatch, Expected {value_search.pattern} but found {version}",
+                        EventPriority.ERROR,
+                        {
+                            "expected_package_search": key_search.pattern,
+                            "found_package": name,
+                            "expected_version_search": value_search.pattern,
+                            "found_version": version,
+                        },
+                    )
+        return value_found, version_mismatches
+
+    def package_regex_search(
+        self, package_data: dict[str, str], exp_package_data: dict[str, Optional[str]]
+    ):
+        """Searches the package data for the expected package and version using regex
+
+        Args:
+            package_data (dict[str, str]): a dictionary of package names and versions
+            exp_package_data (dict[str, Optional[str]]): a dictionary of expected package names and versions
+
+        Returns:
+            tuple: (not_found_keys, regex_errors, version_mismatches) containing lists of errors
+        """
+        not_found_keys = []
+        regex_errors = []
+        version_mismatches = []
+
+        for exp_key, exp_value in exp_package_data.items():
+            try:
+                if exp_value is not None:
+                    value_search = re.compile(exp_value)
+                else:
+                    value_search = None
+                key_search = re.compile(exp_key)
+            except re.error as e:
+                regex_errors.append((exp_key, exp_value, str(e)))
+                self._log_event(
+                    EventCategory.RUNTIME,
+                    f"Regex Compile Error either {exp_key} {exp_value}",
+                    EventPriority.ERROR,
+                    {
+                        "expected_package_search": exp_key,
+                        "expected_version_search": exp_value,
+                    },
+                )
+                continue
+
+            key_found, mismatches = self.regex_version_data(package_data, key_search, value_search)
+
+            # Collect version mismatches
+            version_mismatches.extend(mismatches)
+
+            if not key_found:
+                not_found_keys.append((exp_key, exp_value))
+                self._log_event(
+                    EventCategory.APPLICATION,
+                    f"Package {exp_key} not found in the package list",
+                    EventPriority.ERROR,
+                    {
+                        "expected_package": exp_key,
+                        "found_package": None,
+                        "expected_version": exp_value,
+                        "found_version": None,
+                    },
+                )
+
+        return not_found_keys, regex_errors, version_mismatches
+
+    def package_exact_match(
+        self, package_data: dict[str, str], exp_package_data: dict[str, Optional[str]]
+    ):
+        """Checks the package data for the expected package and version using exact match
+
+        Args:
+            package_data (dict[str, str]): a dictionary of package names and versions
+            exp_package_data (dict[str, Optional[str]]): a dictionary of expected package names and versions
+        """
+        not_found_match = []
+        not_found_version = []
+        for exp_key, exp_value in exp_package_data.items():
+            self.logger.info("Expected value: %s, %s", exp_key, exp_value)
+            version = package_data.get(exp_key)
+            self.logger.info("Found version: %s", version)
+            if version is None:
+                # package not found
+                not_found_version.append((exp_key, exp_value))
+                self._log_event(
+                    EventCategory.APPLICATION,
+                    f"Package {exp_key} not found in the package list",
+                    EventPriority.ERROR,
+                    {
+                        "expected_package": exp_key,
+                        "found_package": None,
+                        "expected_version": exp_value,
+                        "found_version": None,
+                    },
+                )
+            elif exp_value is None:
+                # allow any version when expected version is None
+                continue
+            elif version != exp_value:
+                not_found_match.append((exp_key, version))
+                self._log_event(
+                    EventCategory.APPLICATION,
+                    f"Package {exp_key} Version Mismatch, Expected {exp_value} but found {version}",
+                    EventPriority.ERROR,
+                    {
+                        "expected_package": exp_key,
+                        "found_package": exp_key,
+                        "expected_version": exp_value,
+                        "found_version": version,
+                    },
+                )
+        return not_found_match, not_found_version
+
+    def analyze_data(
+        self, data: PackageDataModel, args: Optional[PackageAnalyzerArgs] = None
+    ) -> TaskResult:
+        """Analyze the package data against the expected package version data
+
+        Args:
+            data (PackageDataModel): package data to analyze
+            args (Optional[PackageAnalyzerArgs], optional): package analysis arguments. Defaults to None.
+
+        Returns:
+            TaskResult: the result of the analysis containing status and message
+        """
+        if not args or not args.exp_package_ver:
+            self.result.message = "Expected Package Version Data not provided"
+            self.result.status = ExecutionStatus.NOT_RAN
+            return self.result
+
+        if args.regex_match:
+            not_found_keys, regex_errors, version_mismatches = self.package_regex_search(
+                data.version_info, args.exp_package_ver
+            )
+
+            # Adding details for err message
+            error_parts = []
+            if not_found_keys:
+                packages_detail = ", ".join(
+                    [
+                        f"'{pkg}' (expected version: {ver if ver else 'any'})"
+                        for pkg, ver in not_found_keys
+                    ]
+                )
+                error_parts.append(f"Packages not found: {packages_detail}")
+
+            if regex_errors:
+                regex_detail = ", ".join(
+                    [f"'{pkg}' pattern (version: {ver})" for pkg, ver, _ in regex_errors]
+                )
+                error_parts.append(f"Regex compile errors: {regex_detail}")
+
+            if version_mismatches:
+                version_detail = ", ".join(
+                    [
+                        f"'{pkg}' (expected: {exp}, found: {found})"
+                        for pkg, exp, found in version_mismatches
+                    ]
+                )
+                error_parts.append(f"Version mismatches: {version_detail}")
+
+            total_errors = len(not_found_keys) + len(regex_errors) + len(version_mismatches)
+            if total_errors > 0:
+                self.result.message = f"{'; '.join(error_parts)}"
+                self.result.status = ExecutionStatus.ERROR
+            else:
+                self.result.message = "All packages found and versions matched"
+                self.result.status = ExecutionStatus.OK
+        else:
+            self.logger.info("Expected packages: %s", list(args.exp_package_ver.keys()))
+            not_found_match, not_found_version = self.package_exact_match(
+                data.version_info, args.exp_package_ver
+            )
+            if not_found_match or not_found_version:
+                self.result.message = f"Package version missmatched. Missmatched versions: {not_found_match}, not found versions: {not_found_version}"
+                self.result.status = ExecutionStatus.ERROR
+
+        return self.result