armodel 1.8.6__py3-none-any.whl → 1.9.1__py3-none-any.whl

armodel/models/M2/AUTOSARTemplates/CommonStructure/ResourceConsumption/SoftwareContext.py

@@ -1,23 +1,68 @@
-from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import String
-from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
-
-class SoftwareContext(ARObject):
-    def __init__(self):
-        super().__init__()
-
-        self.input = None                       # type: String
-        self.state = None                       # type: String
-
-    def getInput(self):
-        return self.input
-
-    def setInput(self, value):
-        self.input = value
-        return self
-
-    def getState(self):
-        return self.state
-
-    def setState(self, value):
-        self.state = value
-        return self
+"""
+This module contains the SoftwareContext class for representing
+software execution context information in AUTOSAR resource consumption models.
+"""
+
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import String
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+
+class SoftwareContext(ARObject):
+    """
+    Represents software execution context information in AUTOSAR models.
+    This class defines the input conditions and execution state for resource consumption analysis.
+    """
+    
+    def __init__(self):
+        """
+        Initializes the SoftwareContext with default values.
+        """
+        super().__init__()
+
+        # Input information for this software context
+        self.input: String = None                       
+        # Execution state for this software context
+        self.state: String = None                       
+
+    def getInput(self):
+        """
+        Gets the input information for this software context.
+        
+        Returns:
+            String: Input information
+        """
+        return self.input
+
+    def setInput(self, value):
+        """
+        Sets the input information for this software context.
+        
+        Args:
+            value: The input information to set
+            
+        Returns:
+            self for method chaining
+        """
+        self.input = value
+        return self
+
+    def getState(self):
+        """
+        Gets the execution state for this software context.
+        
+        Returns:
+            String: Execution state
+        """
+        return self.state
+
+    def setState(self, value):
+        """
+        Sets the execution state for this software context.
+        
+        Args:
+            value: The execution state to set
+            
+        Returns:
+            self for method chaining
+        """
+        self.state = value
+        return self

armodel/models/M2/AUTOSARTemplates/CommonStructure/ResourceConsumption/StackUsage.py

@@ -1,93 +1,275 @@
-from abc import ABCMeta
-from .....M2.AUTOSARTemplates.CommonStructure.ResourceConsumption import SoftwareContext
-from .....M2.AUTOSARTemplates.CommonStructure.ResourceConsumption.HardwareConfiguration import HardwareConfiguration
-from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import PositiveInteger, RefType
-from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
-from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
-
-class StackUsage(Identifiable, metaclass = ABCMeta):
-    def __init__(self, parent: ARObject, short_name: str):
-        if type(self) == StackUsage:
-            raise NotImplementedError("StackUsage is an abstract class.")
-        
-        super().__init__(parent, short_name)
-
-        self.executableEntityRef = None                 # type: RefType
-        self.hardwareConfiguration = None               # type: HardwareConfiguration
-        self.hwElementRef = None                        # type: RefType
-        self.softwareContext = None                     # type: SoftwareContext
-
-    def getExecutableEntityRef(self):
-        return self.executableEntityRef
-
-    def setExecutableEntityRef(self, value):
-        self.executableEntityRef = value
-        return self
-
-    def getHardwareConfiguration(self):
-        return self.hardwareConfiguration
-
-    def setHardwareConfiguration(self, value):
-        self.hardwareConfiguration = value
-        return self
-
-    def getHwElementRef(self):
-        return self.hwElementRef
-
-    def setHwElementRef(self, value):
-        self.hwElementRef = value
-        return self
-
-    def getSoftwareContext(self):
-        return self.softwareContext
-
-    def setSoftwareContext(self, value):
-        self.softwareContext = value
-        return self
-
-class MeasuredStackUsage(StackUsage):
-    def __init__(self, parent: ARObject, short_name: str):
-        super().__init__(parent, short_name)
-
-        self.averageMemoryConsumption = None            # type: PositiveInteger
-        self.maximumMemoryConsumption = None            # type: PositiveInteger
-
-    def getAverageMemoryConsumption(self):
-        return self.averageMemoryConsumption
-
-    def setAverageMemoryConsumption(self, value):
-        self.averageMemoryConsumption = value
-        return self
-
-    def getMaximumMemoryConsumption(self):
-        return self.maximumMemoryConsumption
-
-    def setMaximumMemoryConsumption(self, value):
-        self.maximumMemoryConsumption = value
-        return self
-
-class RoughEstimateStackUsage(StackUsage):
-    def __init__(self, parent, short_name):
-        super().__init__(parent, short_name)
-
-        self.memoryConsumption = None                   # type: PositiveInteger
-
-    def getMemoryConsumption(self):
-        return self.memoryConsumption
-
-    def setMemoryConsumption(self, value):
-        self.memoryConsumption = value
-        return self
-
-class WorstCaseStackUsage(StackUsage):
-    def __init__(self, parent, short_name):
-        super().__init__(parent, short_name)
-
-        self.memoryConsumption = None                   # type: PositiveInteger
-
-    def getMemoryConsumption(self):
-        return self.memoryConsumption
-
-    def setMemoryConsumption(self, value):
-        self.memoryConsumption = value
+"""
+This module contains classes for representing stack usage in AUTOSAR resource consumption models.
+It includes abstract base classes and concrete implementations for different types of stack usage analysis.
+"""
+
+from abc import ABC
+from armodel.models.M2.AUTOSARTemplates.CommonStructure.ResourceConsumption import SoftwareContext
+from armodel.models.M2.AUTOSARTemplates.CommonStructure.ResourceConsumption.HardwareConfiguration import HardwareConfiguration
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import PositiveInteger, RefType
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
+
+class StackUsage(Identifiable, ABC):
+    """
+    Abstract base class for representing stack usage in AUTOSAR models.
+    This class defines the basic structure for stack memory consumption tracking with hardware and software context.
+    """
+    
+    def __init__(self, parent: ARObject, short_name: str):
+        """
+        Initializes the StackUsage with a parent and short name.
+        Raises TypeError if this abstract class is instantiated directly.
+        
+        Args:
+            parent: The parent ARObject that contains this stack usage
+            short_name: The unique short name of this stack usage
+        """
+        if type(self) == StackUsage:
+            raise TypeError("StackUsage is an abstract class.")
+        
+        super().__init__(parent, short_name)
+
+        # Reference to the executable entity for which stack usage is measured
+        self.executableEntityRef: RefType = None                 
+        # Hardware configuration associated with this stack usage
+        self.hardwareConfiguration: HardwareConfiguration = None               
+        # Reference to hardware element for this stack usage
+        self.hwElementRef: RefType = None                        
+        # Software context for this stack usage
+        self.softwareContext: SoftwareContext = None                     
+
+    def getExecutableEntityRef(self):
+        """
+        Gets the reference to the executable entity for which stack usage is measured.
+        
+        Returns:
+            RefType: Reference to the executable entity
+        """
+        return self.executableEntityRef
+
+    def setExecutableEntityRef(self, value):
+        """
+        Sets the reference to the executable entity for which stack usage is measured.
+        
+        Args:
+            value: The executable entity reference to set
+            
+        Returns:
+            self for method chaining
+        """
+        self.executableEntityRef = value
+        return self
+
+    def getHardwareConfiguration(self):
+        """
+        Gets the hardware configuration associated with this stack usage.
+        
+        Returns:
+            HardwareConfiguration: Hardware configuration object
+        """
+        return self.hardwareConfiguration
+
+    def setHardwareConfiguration(self, value):
+        """
+        Sets the hardware configuration associated with this stack usage.
+        
+        Args:
+            value: The hardware configuration to set
+            
+        Returns:
+            self for method chaining
+        """
+        self.hardwareConfiguration = value
+        return self
+
+    def getHwElementRef(self):
+        """
+        Gets the reference to hardware element for this stack usage.
+        
+        Returns:
+            RefType: Reference to hardware element
+        """
+        return self.hwElementRef
+
+    def setHwElementRef(self, value):
+        """
+        Sets the reference to hardware element for this stack usage.
+        
+        Args:
+            value: The hardware element reference to set
+            
+        Returns:
+            self for method chaining
+        """
+        self.hwElementRef = value
+        return self
+
+    def getSoftwareContext(self):
+        """
+        Gets the software context for this stack usage.
+        
+        Returns:
+            SoftwareContext: Software context object
+        """
+        return self.softwareContext
+
+    def setSoftwareContext(self, value):
+        """
+        Sets the software context for this stack usage.
+        
+        Args:
+            value: The software context to set
+            
+        Returns:
+            self for method chaining
+        """
+        self.softwareContext = value
+        return self
+
+class MeasuredStackUsage(StackUsage):
+    """
+    Represents measured stack usage in AUTOSAR models.
+    This class provides concrete measurements of stack consumption under specific conditions.
+    """
+    
+    def __init__(self, parent: ARObject, short_name: str):
+        """
+        Initializes the MeasuredStackUsage with a parent and short name.
+        
+        Args:
+            parent: The parent ARObject that contains this measured stack usage
+            short_name: The unique short name of this measured stack usage
+        """
+        super().__init__(parent, short_name)
+
+        # Average memory consumption measured for this stack usage
+        self.averageMemoryConsumption: PositiveInteger = None            
+        # Maximum memory consumption measured for this stack usage
+        self.maximumMemoryConsumption: PositiveInteger = None            
+
+    def getAverageMemoryConsumption(self):
+        """
+        Gets the average memory consumption measured for this stack usage.
+        
+        Returns:
+            PositiveInteger: Average memory consumption value
+        """
+        return self.averageMemoryConsumption
+
+    def setAverageMemoryConsumption(self, value):
+        """
+        Sets the average memory consumption measured for this stack usage.
+        
+        Args:
+            value: The average memory consumption value to set
+            
+        Returns:
+            self for method chaining
+        """
+        self.averageMemoryConsumption = value
+        return self
+
+    def getMaximumMemoryConsumption(self):
+        """
+        Gets the maximum memory consumption measured for this stack usage.
+        
+        Returns:
+            PositiveInteger: Maximum memory consumption value
+        """
+        return self.maximumMemoryConsumption
+
+    def setMaximumMemoryConsumption(self, value):
+        """
+        Sets the maximum memory consumption measured for this stack usage.
+        
+        Args:
+            value: The maximum memory consumption value to set
+            
+        Returns:
+            self for method chaining
+        """
+        self.maximumMemoryConsumption = value
+        return self
+
+class RoughEstimateStackUsage(StackUsage):
+    """
+    Represents rough estimate stack usage in AUTOSAR models.
+    This class provides estimated values for stack consumption when exact measurements are not available.
+    """
+    
+    def __init__(self, parent, short_name):
+        """
+        Initializes the RoughEstimateStackUsage with a parent and short name.
+        
+        Args:
+            parent: The parent ARObject that contains this rough estimate stack usage
+            short_name: The unique short name of this rough estimate stack usage
+        """
+        super().__init__(parent, short_name)
+
+        # Estimated memory consumption for this stack usage
+        self.memoryConsumption: PositiveInteger = None                   
+
+    def getMemoryConsumption(self):
+        """
+        Gets the estimated memory consumption for this stack usage.
+        
+        Returns:
+            PositiveInteger: Estimated memory consumption value
+        """
+        return self.memoryConsumption
+
+    def setMemoryConsumption(self, value):
+        """
+        Sets the estimated memory consumption for this stack usage.
+        
+        Args:
+            value: The estimated memory consumption value to set
+            
+        Returns:
+            self for method chaining
+        """
+        self.memoryConsumption = value
+        return self
+
+class WorstCaseStackUsage(StackUsage):
+    """
+    Represents worst case stack usage in AUTOSAR models.
+    This class provides the worst-case scenario analysis for stack consumption under maximum load conditions.
+    """
+    
+    def __init__(self, parent, short_name):
+        """
+        Initializes the WorstCaseStackUsage with a parent and short name.
+        
+        Args:
+            parent: The parent ARObject that contains this worst case stack usage
+            short_name: The unique short name of this worst case stack usage
+        """
+        super().__init__(parent, short_name)
+
+        # Memory consumption in worst case scenario for this stack usage
+        self.memoryConsumption: PositiveInteger = None                   
+
+    def getMemoryConsumption(self):
+        """
+        Gets the memory consumption in worst case scenario for this stack usage.
+        
+        Returns:
+            PositiveInteger: Worst case memory consumption value
+        """
+        return self.memoryConsumption
+
+    def setMemoryConsumption(self, value):
+        """
+        Sets the memory consumption in worst case scenario for this stack usage.
+        
+        Args:
+            value: The worst case memory consumption value to set
+            
+        Returns:
+            self for method chaining
+        """
+        self.memoryConsumption = value
         return self

armodel/models/M2/AUTOSARTemplates/CommonStructure/ResourceConsumption/__init__.py

@@ -1,54 +1,136 @@
-from .....M2.AUTOSARTemplates.CommonStructure.ResourceConsumption.StackUsage import MeasuredStackUsage, RoughEstimateStackUsage, StackUsage, WorstCaseStackUsage
-from .....M2.AUTOSARTemplates.CommonStructure.ResourceConsumption.HeapUsage import HeapUsage
-from .....M2.AUTOSARTemplates.CommonStructure.ResourceConsumption.MemorySectionUsage import MemorySection
-from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
-from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
-from typing import List
-
-class ResourceConsumption(Identifiable):
-    def __init__(self, parent: ARObject, short_name: str):
-        super().__init__(parent, short_name)
-
-        self.accessCountSets = []                               # type: List[AccessCountSet]
-        self.executionTimes = []                                # type: List[ExecutionTime]
-        self.heapUsages = []                                    # type: List[HeapUsage]
-        self.memorySections = []
-        self.sectionNamePrefixs = []                            # type: List[SectionNamePrefix]
-        self.stackUsages = []                                   # type: List[StackUsage]
-
-    def createMemorySection(self, short_name: str) -> MemorySection:
-        if (short_name not in self.elements):
-            section = MemorySection(self, short_name)
-            self.addElement(section)
-            self.memorySections.append(section)
-        return self.getElement(short_name)
-
-    def getMemorySections(self) -> List[MemorySection]:
-        return list(sorted(filter(lambda a: isinstance(a, MemorySection), self.elements), key= lambda o:o.short_name))
-
-    def getMemorySection(self, short_name: str) -> MemorySection:
-        return next(filter(lambda o: isinstance(o, MemorySection) and (o.short_name == short_name), self.elements), None)
-    
-    def createMeasuredStackUsage(self, short_name: str) -> MeasuredStackUsage:
-        if (short_name not in self.elements):
-            section = MeasuredStackUsage(self, short_name)
-            self.addElement(section)
-            self.stackUsages.append(section)
-        return self.getElement(short_name)
-    
-    def createRoughEstimateStackUsage(self, short_name: str) -> RoughEstimateStackUsage:
-        if (short_name not in self.elements):
-            section = RoughEstimateStackUsage(self, short_name)
-            self.addElement(section)
-            self.stackUsages.append(section)
-        return self.getElement(short_name)
-    
-    def createWorstCaseStackUsage(self, short_name: str) -> WorstCaseStackUsage:
-        if (short_name not in self.elements):
-            section = WorstCaseStackUsage(self, short_name)
-            self.addElement(section)
-            self.stackUsages.append(section)
-        return self.getElement(short_name)
-    
-    def getStackUsages(self) -> List[StackUsage]:
+"""
+This module contains the ResourceConsumption class and imports related resource consumption classes
+for representing resource consumption in AUTOSAR models. This includes memory sections, stack usage,
+heap usage, and other resource consumption metrics.
+"""
+
+from armodel.models.M2.AUTOSARTemplates.CommonStructure.ResourceConsumption.StackUsage import MeasuredStackUsage, RoughEstimateStackUsage, StackUsage, WorstCaseStackUsage
+from armodel.models.M2.AUTOSARTemplates.CommonStructure.ResourceConsumption.HeapUsage import HeapUsage
+from armodel.models.M2.AUTOSARTemplates.CommonStructure.ResourceConsumption.MemorySectionUsage import MemorySection
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
+from typing import List
+
+class ResourceConsumption(Identifiable):
+    """
+    Represents resource consumption information in AUTOSAR models.
+    This class aggregates various types of resource consumption including memory sections,
+    stack usage, heap usage, execution times, and other resource metrics.
+    """
+    
+    def __init__(self, parent: ARObject, short_name: str):
+        """
+        Initializes the ResourceConsumption with a parent and short name.
+        
+        Args:
+            parent: The parent ARObject that contains this resource consumption
+            short_name: The unique short name of this resource consumption
+        """
+        super().__init__(parent, short_name)
+
+        # List of access count sets for resource consumption analysis
+        self.accessCountSets: List = []                               
+        # List of execution time measurements for resource consumption analysis
+        self.executionTimes: List = []                                
+        # List of heap usage measurements for resource consumption analysis
+        self.heapUsages: List[HeapUsage] = []                                    
+        # List of memory sections for resource consumption analysis
+        self.memorySections = []
+        # List of section name prefixes for resource consumption analysis
+        self.sectionNamePrefixs: List = []                            
+        # List of stack usage measurements for resource consumption analysis
+        self.stackUsages: List[StackUsage] = []                                   
+
+    def createMemorySection(self, short_name: str) -> MemorySection:
+        """
+        Creates and adds a MemorySection to this resource consumption object.
+        
+        Args:
+            short_name: The short name for the new memory section
+            
+        Returns:
+            The created MemorySection instance
+        """
+        if (short_name not in self.elements):
+            section = MemorySection(self, short_name)
+            self.addElement(section)
+            self.memorySections.append(section)
+        return self.getElement(short_name)
+
+    def getMemorySections(self) -> List[MemorySection]:
+        """
+        Gets all MemorySection instances from the elements list, sorted by short name.
+        
+        Returns:
+            List of MemorySection instances sorted by short name
+        """
+        return list(sorted(filter(lambda a: isinstance(a, MemorySection), self.elements), key= lambda o:o.short_name))
+
+    def getMemorySection(self, short_name: str) -> MemorySection:
+        """
+        Gets a specific MemorySection by its short name.
+        
+        Args:
+            short_name: The short name of the memory section to find
+            
+        Returns:
+            MemorySection instance with the specified short name, or None if not found
+        """
+        return next(filter(lambda o: isinstance(o, MemorySection) and (o.short_name == short_name), self.elements), None)
+    
+    def createMeasuredStackUsage(self, short_name: str) -> MeasuredStackUsage:
+        """
+        Creates and adds a MeasuredStackUsage to this resource consumption object.
+        
+        Args:
+            short_name: The short name for the new measured stack usage
+            
+        Returns:
+            The created MeasuredStackUsage instance
+        """
+        if (short_name not in self.elements):
+            section = MeasuredStackUsage(self, short_name)
+            self.addElement(section)
+            self.stackUsages.append(section)
+        return self.getElement(short_name)
+    
+    def createRoughEstimateStackUsage(self, short_name: str) -> RoughEstimateStackUsage:
+        """
+        Creates and adds a RoughEstimateStackUsage to this resource consumption object.
+        
+        Args:
+            short_name: The short name for the new rough estimate stack usage
+            
+        Returns:
+            The created RoughEstimateStackUsage instance
+        """
+        if (short_name not in self.elements):
+            section = RoughEstimateStackUsage(self, short_name)
+            self.addElement(section)
+            self.stackUsages.append(section)
+        return self.getElement(short_name)
+    
+    def createWorstCaseStackUsage(self, short_name: str) -> WorstCaseStackUsage:
+        """
+        Creates and adds a WorstCaseStackUsage to this resource consumption object.
+        
+        Args:
+            short_name: The short name for the new worst case stack usage
+            
+        Returns:
+            The created WorstCaseStackUsage instance
+        """
+        if (short_name not in self.elements):
+            section = WorstCaseStackUsage(self, short_name)
+            self.addElement(section)
+            self.stackUsages.append(section)
+        return self.getElement(short_name)
+    
+    def getStackUsages(self) -> List[StackUsage]:
+        """
+        Gets all StackUsage instances from the elements list, sorted by short name.
+        
+        Returns:
+            List of StackUsage instances sorted by short name
+        """
         return list(sorted(filter(lambda a: isinstance(a, StackUsage), self.elements), key= lambda o:o.short_name))