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

nodescraper/enums/systeminteraction.py

@@ -0,0 +1,41 @@
+###############################################################################
+#
+# 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 enum import IntEnum
+from functools import total_ordering
+
+
+@total_ordering
+class SystemInteractionLevel(IntEnum):
+    """Interaction levels, used to determine what types of actions can be taken when interacting with system"""
+
+    PASSIVE = 0  # read only data collection
+    INTERACTIVE = 1  # enable actions that may modify state of the SUT
+    DISRUPTIVE = 2  # enable actions that can interfere with driver or other core components
+
+    def __lt__(self, other: "SystemInteractionLevel") -> bool:
+        if self.__class__ is other.__class__:
+            return self.value < other.value
+        return NotImplemented

nodescraper/enums/systemlocation.py

@@ -0,0 +1,33 @@
+###############################################################################
+#
+# 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 enum
+
+
+class SystemLocation(enum.Enum):
+    """Enum defining location of system"""
+
+    LOCAL = enum.auto()
+    REMOTE = enum.auto()

nodescraper/generictypes.py

@@ -0,0 +1,36 @@
+###############################################################################
+#
+# 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 TYPE_CHECKING, Optional, TypeVar
+
+from pydantic import BaseModel
+
+if TYPE_CHECKING:
+    from nodescraper.models import DataModel
+
+TDataModel = TypeVar("TDataModel", bound="DataModel")
+TModelType = TypeVar("TModelType", bound=BaseModel)
+TCollectArg = TypeVar("TCollectArg", bound=Optional[BaseModel])
+TAnalyzeArg = TypeVar("TAnalyzeArg", bound=Optional[BaseModel])

nodescraper/interfaces/__init__.py

@@ -0,0 +1,44 @@
+###############################################################################
+#
+# 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 .connectionmanager import ConnectionManager
+from .dataanalyzertask import DataAnalyzer
+from .datacollectortask import DataCollector
+from .dataplugin import DataPlugin
+from .plugin import PluginInterface
+from .resultcollator import PluginResultCollator
+from .task import Task
+from .taskresulthook import TaskResultHook
+
+__all__ = [
+    "ConnectionManager",
+    "Task",
+    "DataPlugin",
+    "DataAnalyzer",
+    "DataCollector",
+    "PluginInterface",
+    "TaskResultHook",
+    "PluginResultCollator",
+]

nodescraper/interfaces/connectionmanager.py

@@ -0,0 +1,143 @@
+###############################################################################
+#
+# 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 __future__ import annotations
+
+import abc
+import logging
+import types
+from functools import wraps
+from typing import Callable, Generic, Optional, TypeVar, Union
+
+from pydantic import BaseModel
+
+from nodescraper.enums import EventCategory, EventPriority, ExecutionStatus
+from nodescraper.models import SystemInfo, TaskResult
+from nodescraper.typeutils import TypeUtils
+from nodescraper.utils import get_exception_traceback
+
+from .task import Task
+from .taskresulthook import TaskResultHook
+
+
+def connect_decorator(func: Callable[..., TaskResult]) -> Callable[..., TaskResult]:
+    @wraps(func)
+    def wrapper(
+        connection_manager: "ConnectionManager",
+        **kwargs,
+    ) -> TaskResult:
+        connection_manager.logger.info(
+            "Initializing connection: %s", connection_manager.__class__.__name__
+        )
+        connection_manager.result = connection_manager._init_result()
+
+        try:
+            result = func(connection_manager, **kwargs)
+        except Exception as exception:
+            connection_manager._log_event(
+                category=EventCategory.RUNTIME,
+                description=f"Exception: {str(exception)}",
+                data=get_exception_traceback(exception),
+                priority=EventPriority.CRITICAL,
+                console_log=True,
+            )
+            connection_manager.result.status = ExecutionStatus.EXECUTION_FAILURE
+            result = connection_manager.result
+
+        result.finalize()
+
+        connection_manager._run_hooks(result)
+
+        return result
+
+    return wrapper
+
+
+TConnection = TypeVar("TConnection")
+TConnectionManager = TypeVar("TConnectionManager", bound="ConnectionManager")
+TConnectArg = TypeVar("TConnectArg", bound="Optional[BaseModel]")
+
+
+class ConnectionManager(Task, Generic[TConnection, TConnectArg]):
+    """Base class for all connection management tasks"""
+
+    TASK_TYPE = "CONNECTION_MANAGER"
+
+    def __init__(
+        self,
+        system_info: SystemInfo,
+        logger: Optional[logging.Logger] = None,
+        max_event_priority_level: Union[EventPriority, str] = EventPriority.CRITICAL,
+        parent: Optional[str] = None,
+        task_result_hooks: Optional[list[TaskResultHook], None] = None,
+        connection_args: Optional[Union[TConnectArg, dict]] = None,
+        **kwargs,
+    ):
+        super().__init__(
+            system_info=system_info,
+            logger=logger,
+            max_event_priority_level=max_event_priority_level,
+            parent="connection" if not parent else parent,
+            task_result_hooks=task_result_hooks,
+            **kwargs,
+        )
+
+        if isinstance(connection_args, dict):
+            generic_map = TypeUtils.get_generic_map(self.__class__)
+            connection_arg_model = generic_map.get(TConnectArg)
+            if not connection_arg_model:
+                raise ValueError("No model defined for connection args")
+
+            connection_args = connection_arg_model(**connection_args)
+
+        self.connection_args = connection_args
+        self.connection: Optional[TConnection] = None
+
+    def __init_subclass__(cls, **kwargs) -> None:
+        super().__init_subclass__(**kwargs)
+
+        if hasattr(cls, "connect"):
+            cls.connect = connect_decorator(cls.connect)
+
+    def __enter__(self):
+        """Context manager enter"""
+        return self
+
+    def __exit__(
+        self,
+        _exc_type: type[Exception],
+        _exc_value: Exception,
+        traceback: types.TracebackType,
+    ):
+        self.disconnect()
+
+    @abc.abstractmethod
+    def connect(self) -> TaskResult:
+        """initialize connection"""
+
+    def disconnect(self):
+        """disconnect connection (Optional)"""
+        self.connection = None
+        self.result.status = ExecutionStatus.UNSET

nodescraper/interfaces/dataanalyzertask.py

@@ -0,0 +1,138 @@
+###############################################################################
+#
+# 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 __future__ import annotations
+
+import abc
+import inspect
+from functools import wraps
+from typing import Any, Callable, Generic, Optional, Type, Union
+
+from pydantic import BaseModel, ValidationError
+
+from nodescraper.enums import EventCategory, EventPriority, ExecutionStatus
+from nodescraper.generictypes import TAnalyzeArg, TDataModel
+from nodescraper.interfaces.task import Task
+from nodescraper.models import TaskResult
+from nodescraper.models.datamodel import DataModel
+from nodescraper.typeutils import TypeUtils
+from nodescraper.utils import get_exception_traceback
+
+
+def analyze_decorator(func: Callable[..., TaskResult]) -> Callable[..., TaskResult]:
+    @wraps(func)
+    def wrapper(
+        analyzer: "DataAnalyzer",
+        data: DataModel,
+        args: Optional[Union[TAnalyzeArg, dict]] = None,
+    ) -> TaskResult:
+        analyzer.logger.info("Running data analyzer: %s", analyzer.__class__.__name__)
+        analyzer.result = analyzer._init_result()
+
+        if not isinstance(data, analyzer.DATA_MODEL):
+            analyzer._log_event(
+                category=EventCategory.RUNTIME,
+                description="Analyzer passed invalid data",
+                data={"data_type": type(data), "expected": analyzer.DATA_MODEL.__name__},
+                priority=EventPriority.CRITICAL,
+                console_log=True,
+            )
+            analyzer.result.message = "Invalid data input"
+            analyzer.result.status = ExecutionStatus.EXECUTION_FAILURE
+        else:
+            try:
+                if isinstance(args, dict):
+                    arg_types = TypeUtils.get_func_arg_types(func)
+                    analyze_arg_model = next(
+                        (
+                            type_class.type_class
+                            for type_class in arg_types["args"].type_classes
+                            if issubclass(type_class.type_class, BaseModel)
+                        ),
+                        None,
+                    )
+                    if not analyze_arg_model:
+                        raise ValueError("No model defined for analysis args")
+                    args = analyze_arg_model(**args)  # type: ignore
+                func(analyzer, data, args)
+            except ValidationError as exception:
+                analyzer._log_event(
+                    category=EventCategory.RUNTIME,
+                    description="Validation error during analysis",
+                    data={"errors": exception.errors(include_url=False)},
+                    priority=EventPriority.CRITICAL,
+                    console_log=True,
+                )
+                analyzer.result.status = ExecutionStatus.EXECUTION_FAILURE
+            except Exception as exception:
+                analyzer._log_event(
+                    category=EventCategory.RUNTIME,
+                    description=f"Exception during data analysis: {str(exception)}",
+                    data=get_exception_traceback(exception),
+                    priority=EventPriority.CRITICAL,
+                    console_log=True,
+                )
+                analyzer.result.status = ExecutionStatus.EXECUTION_FAILURE
+
+        result = analyzer.result
+        result.finalize(analyzer.logger)
+
+        analyzer._run_hooks(result)
+
+        return result
+
+    return wrapper
+
+
+class DataAnalyzer(Task, abc.ABC, Generic[TDataModel, TAnalyzeArg]):
+    """Parent class for all data analyzers"""
+
+    TASK_TYPE = "DATA_ANALYZER"
+
+    DATA_MODEL: Type[TDataModel]
+
+    def __init_subclass__(cls, **kwargs: dict[str, Any]) -> None:
+        super().__init_subclass__(**kwargs)
+        if not inspect.isabstract(cls) and cls.DATA_MODEL is None:
+            raise TypeError(f"No data model set for {cls.__name__}")
+
+        if hasattr(cls, "analyze_data"):
+            setattr(cls, "analyze_data", analyze_decorator(cls.analyze_data))  # noqa
+
+    @abc.abstractmethod
+    def analyze_data(
+        self,
+        data: TDataModel,
+        args: Optional[TAnalyzeArg],
+    ) -> TaskResult:
+        """Analyze the provided data and return a TaskResult
+
+        Args:
+            data (TDataModel): data to analyze
+            args (Optional[TAnalyzeArg]): Optional arguments for analysis. Dicts will be handled in the decorator"
+
+        Returns:
+            TaskResult: Task result containing the analysis outcome
+        """

nodescraper/interfaces/datacollectortask.py

@@ -0,0 +1,185 @@
+###############################################################################
+#
+# 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 abc
+import inspect
+import logging
+from functools import wraps
+from typing import Callable, ClassVar, Generic, Optional, Type, Union
+
+from pydantic import BaseModel, ValidationError
+
+from nodescraper.enums import (
+    EventCategory,
+    EventPriority,
+    ExecutionStatus,
+    SystemInteractionLevel,
+)
+from nodescraper.generictypes import TCollectArg, TDataModel
+from nodescraper.interfaces.task import SystemCompatibilityError, Task
+from nodescraper.models import DataModel, SystemInfo, TaskResult
+from nodescraper.typeutils import TypeUtils
+from nodescraper.utils import get_exception_traceback
+
+from .connectionmanager import TConnection
+from .taskresulthook import TaskResultHook
+
+
+def collect_decorator(
+    func: Callable[..., tuple[TaskResult, Optional[TDataModel]]],
+) -> Callable[..., tuple[TaskResult, Optional[TDataModel]]]:
+    @wraps(func)
+    def wrapper(
+        collector: "DataCollector", args: Optional[TCollectArg] = None
+    ) -> tuple[TaskResult, Optional[TDataModel]]:
+        collector.logger.info("Running data collector: %s", collector.__class__.__name__)
+        collector.result = collector._init_result()
+        try:
+            if isinstance(args, dict):
+                arg_types = TypeUtils.get_func_arg_types(func)
+                collection_arg_model = next(
+                    (
+                        type_class.type_class
+                        for type_class in arg_types["args"].type_classes
+                        if issubclass(type_class.type_class, BaseModel)
+                    ),
+                    None,
+                )
+                if not collection_arg_model:
+                    raise ValueError("No model defined for analysis args")
+                args = collection_arg_model(**args)  # type: ignore
+            result, data = func(collector, args)
+        except Exception as exception:
+            if isinstance(exception, ValidationError):
+                collector._log_event(
+                    category=EventCategory.RUNTIME,
+                    description="Pydantic validation error",
+                    data={"errors": exception.errors(include_url=False)},
+                    priority=EventPriority.CRITICAL,
+                    console_log=True,
+                )
+            else:
+                collector._log_event(
+                    category=EventCategory.RUNTIME,
+                    description=f"Exception: {str(exception)}",
+                    data=get_exception_traceback(exception),
+                    priority=EventPriority.CRITICAL,
+                    console_log=True,
+                )
+            collector.result.status = ExecutionStatus.EXECUTION_FAILURE
+            result = collector.result
+            data = None
+
+        if data is None and not result.status:
+            result.status = ExecutionStatus.EXECUTION_FAILURE
+
+        result.finalize(collector.logger)
+
+        collector._run_hooks(result, data=data)
+
+        return result, data
+
+    return wrapper
+
+
+class DataCollector(Task, abc.ABC, Generic[TConnection, TDataModel, TCollectArg]):
+    """Parent class for all data collectors"""
+
+    TASK_TYPE = "DATA_COLLECTOR"
+
+    DATA_MODEL: Type[TDataModel]
+
+    # A set of supported SKUs for this data collector
+    SUPPORTED_SKUS: ClassVar[Optional[set[str]]] = None
+
+    # A set of supported Platforms for this data collector,
+    SUPPORTED_PLATFORMS: ClassVar[Optional[set[str]]] = None
+
+    def __init__(
+        self,
+        system_info: SystemInfo,
+        connection: TConnection,
+        logger: Optional[logging.Logger] = None,
+        system_interaction_level: Union[
+            SystemInteractionLevel, str
+        ] = SystemInteractionLevel.INTERACTIVE,
+        max_event_priority_level: Union[EventPriority, str] = EventPriority.CRITICAL,
+        parent: Optional[str] = None,
+        task_result_hooks: Optional[list[TaskResultHook]] = None,
+        **kwargs,
+    ):
+        """data collector init function
+
+        Args:
+            system_info (SystemInfo): system info object for target system for data collection
+            system_interaction (SystemInteraction): enum to indicate the type of actions that can be performed when interacting with the system
+            event_reporter (str, optional): Described the reporter of the event. Defaults to DEFAULT_EVENT_REPORTER.
+            logger (Optional[logging.Logger], optional): python logger object. Defaults to None.
+            log_path (Optional[str], optional): file system log path. Defaults to None.
+        """
+        super().__init__(
+            system_info=system_info,
+            logger=logger,
+            max_event_priority_level=max_event_priority_level,
+            parent=parent,
+            task_result_hooks=task_result_hooks,
+        )
+
+        if isinstance(system_interaction_level, str):
+            system_interaction_level = getattr(SystemInteractionLevel, system_interaction_level)
+
+        self.system_interaction_level = system_interaction_level
+        self.connection = connection
+
+        if self.SUPPORTED_SKUS and self.system_info.sku not in self.SUPPORTED_SKUS:
+            raise SystemCompatibilityError(
+                f"{self.system_info.sku} SKU is not supported for this collector"
+            )
+        if self.SUPPORTED_PLATFORMS and self.system_info.platform not in self.SUPPORTED_PLATFORMS:
+            raise SystemCompatibilityError(
+                f"{self.system_info.platform} platform is not supported for this collector"
+            )
+
+    def __init_subclass__(cls, **kwargs) -> None:
+        super().__init_subclass__(**kwargs)
+        if not inspect.isabstract(cls):
+            if not hasattr(cls, "DATA_MODEL"):
+                raise TypeError(f"No data model set for {cls.__name__}")
+            if not issubclass(cls.DATA_MODEL, DataModel):
+                raise TypeError(f"DATA_MODEL must be a subclass of DataModel in {cls.__name__}")
+        if hasattr(cls, "collect_data"):
+            cls.collect_data = collect_decorator(cls.collect_data)
+        else:
+            raise TypeError(f"Data collector {cls.__name__} must implement collect_data")
+
+    @abc.abstractmethod
+    def collect_data(
+        self, args: Optional[TCollectArg] = None
+    ) -> tuple[TaskResult, Optional[TDataModel]]:
+        """Collect data from a target system
+
+        Returns:
+            tuple[TaskResult, DataModel]: tuple containing result and data model
+        """