armodel 1.8.7__py3-none-any.whl → 1.9.2__py3-none-any.whl

armodel/models/M2/AUTOSARTemplates/CommonStructure/Timing/TimingClock/TimingClockSyncAccuracy.py

@@ -0,0 +1,60 @@
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+
+
+class TimingClockSyncAccuracy(ARObject):
+    """
+    Represents timing clock synchronization accuracy in AUTOSAR.
+    Defines the accuracy of clock synchronization.
+    """
+
+    def __init__(self):
+        """
+        Initializes the TimingClockSyncAccuracy with default values.
+        """
+        super().__init__()
+        self.accuracy: str = None
+        self.unit: str = None
+
+    def getAccuracy(self) -> str:
+        """
+        Gets the accuracy value.
+
+        Returns:
+            String representing the accuracy
+        """
+        return self.accuracy
+
+    def setAccuracy(self, value: str):
+        """
+        Sets the accuracy value.
+
+        Args:
+            value: String value to set
+
+        Returns:
+            self for method chaining
+        """
+        self.accuracy = value
+        return self
+
+    def getUnit(self) -> str:
+        """
+        Gets the unit.
+
+        Returns:
+            String representing the unit
+        """
+        return self.unit
+
+    def setUnit(self, value: str):
+        """
+        Sets the unit.
+
+        Args:
+            value: String value to set
+
+        Returns:
+            self for method chaining
+        """
+        self.unit = value
+        return self

armodel/models/M2/AUTOSARTemplates/CommonStructure/Timing/TimingClock/__init__.py

@@ -0,0 +1,5 @@
+from armodel.models.M2.AUTOSARTemplates.CommonStructure.Timing.TDLETZoneClock import TDLETZoneClock
+from armodel.models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingClock import TimingClock
+from armodel.models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingClockSyncAccuracy import TimingClockSyncAccuracy
+
+__all__ = ['TDLETZoneClock', 'TimingClock', 'TimingClockSyncAccuracy']

armodel/models/M2/AUTOSARTemplates/CommonStructure/Timing/TimingCondition/ModeInBswInstanceRef.py

@@ -0,0 +1,14 @@
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType
+
+
+class ModeInBswInstanceRef(RefType):
+    """
+    Represents a reference to a mode in a BSW instance.
+    Used for referencing modes within BSW module instances.
+    """
+
+    def __init__(self):
+        """
+        Initializes the ModeInBswInstanceRef with default values.
+        """
+        super().__init__()

armodel/models/M2/AUTOSARTemplates/CommonStructure/Timing/TimingCondition/ModeInSwcInstanceRef.py

@@ -0,0 +1,14 @@
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType
+
+
+class ModeInSwcInstanceRef(RefType):
+    """
+    Represents a reference to a mode in a SWC instance.
+    Used for referencing modes within software component instances.
+    """
+
+    def __init__(self):
+        """
+        Initializes the ModeInSwcInstanceRef with default values.
+        """
+        super().__init__()

armodel/models/M2/AUTOSARTemplates/CommonStructure/Timing/TimingCondition/TimingCondition.py

@@ -0,0 +1,61 @@
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from typing import List
+
+
+class TimingCondition(ARObject):
+    """
+    Represents a timing condition in AUTOSAR timing specifications.
+    Defines conditions that affect timing behavior.
+    """
+
+    def __init__(self):
+        """
+        Initializes the TimingCondition with default values.
+        """
+        super().__init__()
+        self.conditionFormula: str = None
+        self.modeInstances: List[str] = []
+
+    def getConditionFormula(self) -> str:
+        """
+        Gets the condition formula.
+
+        Returns:
+            String representing the condition formula
+        """
+        return self.conditionFormula
+
+    def setConditionFormula(self, value: str):
+        """
+        Sets the condition formula.
+
+        Args:
+            value: String value to set
+
+        Returns:
+            self for method chaining
+        """
+        self.conditionFormula = value
+        return self
+
+    def addModeInstance(self, instance: str):
+        """
+        Adds a mode instance to this timing condition.
+
+        Args:
+            instance: The mode instance to add
+
+        Returns:
+            self for method chaining
+        """
+        self.modeInstances.append(instance)
+        return self
+
+    def getModeInstances(self) -> List[str]:
+        """
+        Gets the list of mode instances.
+
+        Returns:
+            List of mode instances
+        """
+        return self.modeInstances

armodel/models/M2/AUTOSARTemplates/CommonStructure/Timing/TimingCondition/TimingConditionFormula.py

@@ -0,0 +1,37 @@
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+
+
+class TimingConditionFormula(ARObject):
+    """
+    Represents a timing condition formula in AUTOSAR.
+    Defines a formula for evaluating timing conditions.
+    """
+
+    def __init__(self):
+        """
+        Initializes the TimingConditionFormula with default values.
+        """
+        super().__init__()
+        self.expression: str = None
+
+    def getExpression(self) -> str:
+        """
+        Gets the formula expression.
+
+        Returns:
+            String representing the expression
+        """
+        return self.expression
+
+    def setExpression(self, value: str):
+        """
+        Sets the formula expression.
+
+        Args:
+            value: String value to set
+
+        Returns:
+            self for method chaining
+        """
+        self.expression = value
+        return self

armodel/models/M2/AUTOSARTemplates/CommonStructure/Timing/TimingCondition/TimingExtensionResource.py

@@ -0,0 +1,60 @@
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+
+
+class TimingExtensionResource(ARObject):
+    """
+    Represents a timing extension resource in AUTOSAR.
+    Defines resources used for timing extensions.
+    """
+
+    def __init__(self):
+        """
+        Initializes the TimingExtensionResource with default values.
+        """
+        super().__init__()
+        self.resourceName: str = None
+        self.resourceType: str = None
+
+    def getResourceName(self) -> str:
+        """
+        Gets the resource name.
+
+        Returns:
+            String representing the resource name
+        """
+        return self.resourceName
+
+    def setResourceName(self, value: str):
+        """
+        Sets the resource name.
+
+        Args:
+            value: String value to set
+
+        Returns:
+            self for method chaining
+        """
+        self.resourceName = value
+        return self
+
+    def getResourceType(self) -> str:
+        """
+        Gets the resource type.
+
+        Returns:
+            String representing the resource type
+        """
+        return self.resourceType
+
+    def setResourceType(self, value: str):
+        """
+        Sets the resource type.
+
+        Args:
+            value: String value to set
+
+        Returns:
+            self for method chaining
+        """
+        self.resourceType = value
+        return self

armodel/models/M2/AUTOSARTemplates/CommonStructure/Timing/TimingCondition/TimingModeInstance.py

@@ -0,0 +1,61 @@
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType
+
+
+class TimingModeInstance(ARObject):
+    """
+    Represents a timing mode instance in AUTOSAR.
+    Defines a mode instance used in timing specifications.
+    """
+
+    def __init__(self):
+        """
+        Initializes the TimingModeInstance with default values.
+        """
+        super().__init__()
+        self.modeRef: RefType = None
+        self.modeValue: str = None
+
+    def getModeRef(self) -> RefType:
+        """
+        Gets the mode reference.
+
+        Returns:
+            Reference to the mode
+        """
+        return self.modeRef
+
+    def setModeRef(self, value: RefType):
+        """
+        Sets the mode reference.
+
+        Args:
+            value: The mode reference to set
+
+        Returns:
+            self for method chaining
+        """
+        self.modeRef = value
+        return self
+
+    def getModeValue(self) -> str:
+        """
+        Gets the mode value.
+
+        Returns:
+            String representing the mode value
+        """
+        return self.modeValue
+
+    def setModeValue(self, value: str):
+        """
+        Sets the mode value.
+
+        Args:
+            value: String value to set
+
+        Returns:
+            self for method chaining
+        """
+        self.modeValue = value
+        return self

armodel/models/M2/AUTOSARTemplates/CommonStructure/Timing/TimingCondition/__init__.py

@@ -0,0 +1,15 @@
+from armodel.models.M2.AUTOSARTemplates.CommonStructure.Timing.ModeInBswInstanceRef import ModeInBswInstanceRef
+from armodel.models.M2.AUTOSARTemplates.CommonStructure.Timing.ModeInSwcInstanceRef import ModeInSwcInstanceRef
+from armodel.models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingCondition import TimingCondition
+from armodel.models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingConditionFormula import TimingConditionFormula
+from armodel.models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingExtensionResource import TimingExtensionResource
+from armodel.models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingModeInstance import TimingModeInstance
+
+__all__ = [
+    'ModeInBswInstanceRef',
+    'ModeInSwcInstanceRef',
+    'TimingCondition',
+    'TimingConditionFormula',
+    'TimingExtensionResource',
+    'TimingModeInstance'
+]

armodel/models/M2/AUTOSARTemplates/CommonStructure/Timing/TimingConstraint/AgeConstraint.py

@@ -0,0 +1,57 @@
+"""
+This module defines age constraints in AUTOSAR timing specifications.
+
+Age constraints specify the maximum allowed age of data between its creation
+and its consumption, ensuring data freshness requirements are met.
+
+Classes:
+    AgeConstraint: Specifies the maximum allowed age of data
+"""
+
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import (
+    TimeValue,
+)
+from armodel.models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingConstraint import TimingConstraint
+
+
+class AgeConstraint(TimingConstraint):
+    """
+    Specifies the maximum allowed age of data in AUTOSAR timing specifications.
+    This constraint ensures that data is consumed within a specified time
+    window after its creation, maintaining data freshness.
+    """
+
+    def __init__(self, parent, short_name: str):
+        """
+        Initializes the AgeConstraint with a parent and short name.
+
+        Args:
+            parent: The parent ARObject that contains this age constraint
+            short_name: The unique short name of this age constraint
+        """
+        super().__init__(parent, short_name)
+
+        # Maximum allowed age of the data
+        self.age: TimeValue = None
+
+    def getAge(self):
+        """
+        Gets the maximum allowed age of the data.
+
+        Returns:
+            TimeValue: The maximum allowed age
+        """
+        return self.age
+
+    def setAge(self, value):
+        """
+        Sets the maximum allowed age of the data.
+
+        Args:
+            value: The maximum allowed age to set
+
+        Returns:
+            self for method chaining
+        """
+        self.age = value
+        return self

armodel/models/M2/AUTOSARTemplates/CommonStructure/Timing/TimingConstraint/EventTriggeringConstraint.py

@@ -0,0 +1,203 @@
+"""
+This module defines event triggering constraints in AUTOSAR timing specifications.
+
+Event triggering constraints specify timing requirements for event triggering
+patterns such as periodic, sporadic, or burst patterns.
+
+Classes:
+    EventTriggeringConstraint: Abstract base for event triggering constraints
+    PeriodicEventTriggering: Specifies periodic event triggering
+    SporadicEventTriggering: Specifies sporadic event triggering
+    ArbitraryEventTriggering: Specifies arbitrary event triggering
+    BurstPatternEventTriggering: Specifies burst pattern event triggering
+    ConcretePatternEventTriggering: Specifies concrete pattern event triggering
+    ConfidenceInterval: Specifies confidence interval for timing measurements
+"""
+
+from abc import ABC
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import (
+    TimeValue,
+    Float,
+)
+from armodel.models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingConstraint import TimingConstraint
+
+
+class EventTriggeringConstraint(TimingConstraint, ABC):
+    """
+    Abstract base class for event triggering constraints.
+    This class cannot be instantiated directly and serves as the base for
+    concrete event triggering constraint implementations.
+    """
+
+    def __init__(self, parent, short_name: str):
+        if type(self) is EventTriggeringConstraint:
+            raise TypeError("EventTriggeringConstraint is an abstract class.")
+
+        super().__init__(parent, short_name)
+
+
+class PeriodicEventTriggering(EventTriggeringConstraint):
+    """
+    Specifies periodic event triggering requirements.
+    This constraint defines the period for periodic event triggering.
+    """
+
+    def __init__(self, parent, short_name: str):
+        """
+        Initializes the PeriodicEventTriggering with a parent and short name.
+
+        Args:
+            parent: The parent ARObject that contains this constraint
+            short_name: The unique short name of this constraint
+        """
+        super().__init__(parent, short_name)
+
+        # Period for event triggering
+        self.period: TimeValue = None
+
+    def getPeriod(self):
+        return self.period
+
+    def setPeriod(self, value):
+        self.period = value
+        return self
+
+
+class SporadicEventTriggering(EventTriggeringConstraint):
+    """
+    Specifies sporadic event triggering requirements.
+    This constraint defines the minimum inter-arrival time for sporadic events.
+    """
+
+    def __init__(self, parent, short_name: str):
+        """
+        Initializes the SporadicEventTriggering with a parent and short name.
+
+        Args:
+            parent: The parent ARObject that contains this constraint
+            short_name: The unique short name of this constraint
+        """
+        super().__init__(parent, short_name)
+
+        # Minimum inter-arrival time
+        self.min_inter_arrival_time: TimeValue = None
+
+    def getMinInterArrivalTime(self):
+        return self.min_inter_arrival_time
+
+    def setMinInterArrivalTime(self, value):
+        self.min_inter_arrival_time = value
+        return self
+
+
+class ArbitraryEventTriggering(EventTriggeringConstraint):
+    """
+    Specifies arbitrary event triggering requirements.
+    This constraint allows for arbitrary event triggering patterns.
+    """
+
+    def __init__(self, parent, short_name: str):
+        """
+        Initializes the ArbitraryEventTriggering with a parent and short name.
+
+        Args:
+            parent: The parent ARObject that contains this constraint
+            short_name: The unique short name of this constraint
+        """
+        super().__init__(parent, short_name)
+
+
+class BurstPatternEventTriggering(EventTriggeringConstraint):
+    """
+    Specifies burst pattern event triggering requirements.
+    This constraint defines burst pattern parameters for event triggering.
+    """
+
+    def __init__(self, parent, short_name: str):
+        """
+        Initializes the BurstPatternEventTriggering with a parent and short name.
+
+        Args:
+            parent: The parent ARObject that contains this constraint
+            short_name: The unique short name of this constraint
+        """
+        super().__init__(parent, short_name)
+
+        # Number of events in burst
+        self.burst_size: int = None
+        # Burst interval
+        self.burst_interval: TimeValue = None
+
+    def getBurstSize(self):
+        return self.burst_size
+
+    def setBurstSize(self, value):
+        self.burst_size = value
+        return self
+
+    def getBurstInterval(self):
+        return self.burst_interval
+
+    def setBurstInterval(self, value):
+        self.burst_interval = value
+        return self
+
+
+class ConcretePatternEventTriggering(EventTriggeringConstraint):
+    """
+    Specifies concrete pattern event triggering requirements.
+    This constraint defines a concrete pattern for event triggering.
+    """
+
+    def __init__(self, parent, short_name: str):
+        """
+        Initializes the ConcretePatternEventTriggering with a parent and short name.
+
+        Args:
+            parent: The parent ARObject that contains this constraint
+            short_name: The unique short name of this constraint
+        """
+        super().__init__(parent, short_name)
+
+
+class ConfidenceInterval(ARObject):
+    """
+    Specifies a confidence interval for timing measurements.
+    This class defines the confidence interval with a confidence level
+    and interval bounds.
+    """
+
+    def __init__(self):
+        """
+        Initializes the ConfidenceInterval with default values.
+        """
+        super().__init__()
+
+        # Confidence level (e.g., 0.95 for 95% confidence)
+        self.confidence_level: Float = None
+        # Lower bound of the interval
+        self.lower_bound: TimeValue = None
+        # Upper bound of the interval
+        self.upper_bound: TimeValue = None
+
+    def getConfidenceLevel(self):
+        return self.confidence_level
+
+    def setConfidenceLevel(self, value):
+        self.confidence_level = value
+        return self
+
+    def getLowerBound(self):
+        return self.lower_bound
+
+    def setLowerBound(self, value):
+        self.lower_bound = value
+        return self
+
+    def getUpperBound(self):
+        return self.upper_bound
+
+    def setUpperBound(self, value):
+        self.upper_bound = value
+        return self