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

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

@@ -1,45 +1,193 @@
-from typing import List
-from abc import ABCMeta
-from ......M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
-from ......M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
-from ......M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType
-from ......M2.AUTOSARTemplates.CommonStructure.Timing.TimingConstraint.TimingConstraint import TimingConstraint
-
-class EOCExecutableEntityRefAbstract(Identifiable):
-    __metaclass__ = ABCMeta
-
-    def __init__(self, parent: ARObject, short_name: str):
-        if type(self) == TimingConstraint:
-            raise NotImplementedError("TimingExtension is an abstract class.")
-
-        super().__init__(parent, short_name)
-
-
-class EOCExecutableEntityRef(EOCExecutableEntityRefAbstract):
-    def __init__(self, parent: ARObject, short_name: str):
-        super().__init__(parent, short_name)
-
-        self.successor_refs = []            # List[RefType]
-
-    def addSuccessorRef(self, ref: RefType):
-        self.successor_refs.append(ref)
-
-    def getSuccessorRefs(self) -> List[RefType]:
-        return self.successor_refs
-
-
-class ExecutionOrderConstraint(TimingConstraint):
-    def __init__(self, parent: ARObject, short_name: str):
-        super().__init__(parent, short_name)
-
-        self.ordered_elements = []                      # type: List[EOCExecutableEntityRefAbstract]
-
-    def createEOCExecutableEntityRef(self, short_name: str)-> EOCExecutableEntityRef:
-        if not self.IsElementExists(short_name):
-            entity_ref = EOCExecutableEntityRef(self, short_name)
-            self.addElement(entity_ref)
-            self.ordered_elements.append(entity_ref)
-        return self.getElement(short_name, EOCExecutableEntityRef)
-
-    def getOrderedElements(self) -> List[EOCExecutableEntityRefAbstract]:
-        return self.ordered_elements
+"""
+This module defines classes for execution order constraint entities in AUTOSAR timing specifications.
+
+The execution order constraint mechanism allows defining the execution sequence of runnables
+within AUTOSAR software components. It defines abstract and concrete classes for representing
+executable entity references and their ordering constraints.
+
+Classes:
+    EOCExecutableEntityRefAbstract: Abstract base class for executable entity references
+    EOCExecutableEntityRef: Concrete implementation of executable entity reference
+    ExecutionOrderConstraint: Constraint defining the execution order of entities
+"""
+
+from typing import List
+from abc import ABC
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType
+from armodel.models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingConstraint.TimingConstraint import TimingConstraint
+
+
+class EOCExecutableEntityRefAbstract(Identifiable, ABC):
+    """
+    Abstract base class for execution order constraint executable entity references.
+    This class cannot be instantiated directly and serves as the base for concrete implementations.
+    """
+
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) is EOCExecutableEntityRefAbstract:
+            raise TypeError("EOCExecutableEntityRefAbstract is an abstract class.")
+
+        super().__init__(parent, short_name)
+
+
+class EOCExecutableEntityRef(EOCExecutableEntityRefAbstract):
+    """
+    Concrete implementation of executable entity reference for execution order constraints.
+    Represents a specific runnable or executable entity in an execution order constraint.
+    """
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.successor_refs: List[RefType] = []
+
+    def addSuccessorRef(self, ref: RefType):
+        """
+        Adds a reference to a successor executable entity.
+        
+        Args:
+            ref: Reference to the successor entity
+        """
+        self.successor_refs.append(ref)
+
+    def getSuccessorRefs(self) -> List[RefType]:
+        """
+        Returns the list of successor references for this entity.
+        
+        Returns:
+            List of successor entity references
+        """
+        return self.successor_refs
+
+
+class ExecutionOrderConstraint(TimingConstraint):
+    """
+    Execution order constraint defining the execution sequence of executable entities.
+    This constraint specifies the order in which runnables or other executable entities
+    should be executed within a software component.
+    """
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.ordered_elements: List[EOCExecutableEntityRefAbstract] = []
+
+    def createEOCExecutableEntityRef(self, short_name: str)-> EOCExecutableEntityRef:
+        """
+        Creates a new executable entity reference with the specified short name.
+        
+        Args:
+            short_name: Short name for the new entity reference
+            
+        Returns:
+            The created EOCExecutableEntityRef instance
+        """
+        if not self.IsElementExists(short_name):
+            entity_ref = EOCExecutableEntityRef(self, short_name)
+            self.addElement(entity_ref)
+            self.ordered_elements.append(entity_ref)
+        return self.getElement(short_name, EOCExecutableEntityRef)
+
+    def getOrderedElements(self) -> List[EOCExecutableEntityRefAbstract]:
+        """
+        Returns the list of ordered executable entity references.
+        
+        Returns:
+            List of ordered executable entity references
+        """
+        return self.ordered_elements
+
+
+class EOCEventRef(ARObject):
+    """
+    Represents an event reference in execution order constraints.
+    Defines a reference to an event used in execution order specifications.
+    """
+
+    def __init__(self):
+        """
+        Initializes the EOCEventRef with default values.
+        """
+        super().__init__()
+        self.eventRef: RefType = None
+
+    def getEventRef(self) -> RefType:
+        """
+        Gets the event reference.
+
+        Returns:
+            Reference to the event
+        """
+        return self.eventRef
+
+    def setEventRef(self, value: RefType):
+        """
+        Sets the event reference.
+
+        Args:
+            value: The event reference to set
+
+        Returns:
+            self for method chaining
+        """
+        self.eventRef = value
+        return self
+
+
+class EOCExecutableEntityRefGroup(ARObject):
+    """
+    Represents a group of executable entity references in execution order constraints.
+    Defines a collection of executable entity references that can be ordered as a group.
+    """
+
+    def __init__(self):
+        """
+        Initializes the EOCExecutableEntityRefGroup with default values.
+        """
+        super().__init__()
+        self.entityRefs: List[RefType] = []
+
+    def addEntityRef(self, ref: RefType):
+        """
+        Adds an executable entity reference to this group.
+
+        Args:
+            ref: The executable entity reference to add
+
+        Returns:
+            self for method chaining
+        """
+        self.entityRefs.append(ref)
+        return self
+
+    def getEntityRefs(self) -> List[RefType]:
+        """
+        Gets the list of executable entity references.
+
+        Returns:
+            List of executable entity references
+        """
+        return self.entityRefs
+
+
+class ExecutionOrderConstraintTypeEnum:
+    """
+    Enumeration for execution order constraint types in AUTOSAR.
+    Defines different types of execution order constraints.
+    """
+
+    ENUM_BEFORE = "before"
+    ENUM_AFTER = "after"
+    ENUM_IMMEDIATE = "immediate"
+    ENUM_CONCURRENT = "concurrent"
+
+
+class LetDataExchangeParadigmEnum:
+    """
+    Enumeration for LET (Logical Execution Time) data exchange paradigms in AUTOSAR.
+    Defines different paradigms for data exchange in LET timing.
+    """
+
+    ENUM_BUFFERED = "buffered"
+    ENUM_UNBUFFERED = "unbuffered"
+    ENUM_EVENT_TRIGGERED = "event-triggered"

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

@@ -0,0 +1,101 @@
+"""
+This module defines execution time constraints in AUTOSAR timing specifications.
+
+Execution time constraints specify timing requirements for the execution
+of entities such as runnables or operations.
+
+Classes:
+    ExecutionTimeConstraint: Specifies execution time requirements
+    ExecutionTimeTypeEnum: Enumeration for execution time constraint types
+"""
+
+from abc import ABC
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import (
+    TimeValue,
+    AREnum,
+)
+from armodel.models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingConstraint import TimingConstraint
+
+
+class ExecutionTimeTypeEnum(AREnum):
+    """
+    Enumeration for execution time constraint types.
+    """
+
+    BEST_CASE = "best-case"
+    WORST_CASE = "worst-case"
+    AVERAGE_CASE = "average-case"
+
+    def __init__(self):
+        super().__init__((
+            ExecutionTimeTypeEnum.BEST_CASE,
+            ExecutionTimeTypeEnum.WORST_CASE,
+            ExecutionTimeTypeEnum.AVERAGE_CASE,
+        ))
+
+
+class ExecutionTimeConstraint(TimingConstraint):
+    """
+    Specifies execution time requirements for AUTOSAR entities.
+    This constraint defines timing limits for the execution of entities
+    such as runnables, operations, or other executable entities.
+    """
+
+    def __init__(self, parent, short_name: str):
+        """
+        Initializes the ExecutionTimeConstraint with a parent and short name.
+
+        Args:
+            parent: The parent ARObject that contains this execution time constraint
+            short_name: The unique short name of this execution time constraint
+        """
+        super().__init__(parent, short_name)
+
+        # Type of execution time constraint
+        self.execution_type: ExecutionTimeTypeEnum = None
+        # Maximum allowed execution time
+        self.execution_time: TimeValue = None
+
+    def getExecutionType(self):
+        """
+        Gets the type of execution time constraint.
+
+        Returns:
+            ExecutionTimeTypeEnum: The execution time type
+        """
+        return self.execution_type
+
+    def setExecutionType(self, value):
+        """
+        Sets the type of execution time constraint.
+
+        Args:
+            value: The execution time type to set
+
+        Returns:
+            self for method chaining
+        """
+        self.execution_type = value
+        return self
+
+    def getExecutionTime(self):
+        """
+        Gets the maximum allowed execution time.
+
+        Returns:
+            TimeValue: The maximum execution time
+        """
+        return self.execution_time
+
+    def setExecutionTime(self, value):
+        """
+        Sets the maximum allowed execution time.
+
+        Args:
+            value: The maximum execution time to set
+
+        Returns:
+            self for method chaining
+        """
+        self.execution_time = value
+        return self

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

@@ -0,0 +1,100 @@
+"""
+This module defines latency timing constraints in AUTOSAR timing specifications.
+
+Latency constraints specify the maximum allowed time between an event
+occurrence and a response.
+
+Classes:
+    LatencyTimingConstraint: Specifies maximum allowed latency
+    LatencyConstraintTypeEnum: Enumeration for latency constraint types
+"""
+
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import (
+    TimeValue,
+    AREnum,
+)
+from armodel.models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingConstraint import TimingConstraint
+
+
+class LatencyConstraintTypeEnum(AREnum):
+    """
+    Enumeration for latency constraint types.
+    """
+
+    RESPONSE_TIME = "response-time"
+    REACTION_TIME = "reaction-time"
+    END_TO_END_LATENCY = "end-to-end-latency"
+
+    def __init__(self):
+        super().__init__((
+            LatencyConstraintTypeEnum.RESPONSE_TIME,
+            LatencyConstraintTypeEnum.REACTION_TIME,
+            LatencyConstraintTypeEnum.END_TO_END_LATENCY,
+        ))
+
+
+class LatencyTimingConstraint(TimingConstraint):
+    """
+    Specifies latency requirements in AUTOSAR timing specifications.
+    This constraint defines the maximum allowed time between an event
+    occurrence and a response.
+    """
+
+    def __init__(self, parent, short_name: str):
+        """
+        Initializes the LatencyTimingConstraint with a parent and short name.
+
+        Args:
+            parent: The parent ARObject that contains this latency constraint
+            short_name: The unique short name of this latency constraint
+        """
+        super().__init__(parent, short_name)
+
+        # Type of latency constraint
+        self.latency_type: LatencyConstraintTypeEnum = None
+        # Maximum allowed latency
+        self.latency: TimeValue = None
+
+    def getLatencyType(self):
+        """
+        Gets the type of latency constraint.
+
+        Returns:
+            LatencyConstraintTypeEnum: The latency type
+        """
+        return self.latency_type
+
+    def setLatencyType(self, value):
+        """
+        Sets the type of latency constraint.
+
+        Args:
+            value: The latency type to set
+
+        Returns:
+            self for method chaining
+        """
+        self.latency_type = value
+        return self
+
+    def getLatency(self):
+        """
+        Gets the maximum allowed latency.
+
+        Returns:
+            TimeValue: The maximum latency
+        """
+        return self.latency
+
+    def setLatency(self, value):
+        """
+        Sets the maximum allowed latency.
+
+        Args:
+            value: The maximum latency to set
+
+        Returns:
+            self for method chaining
+        """
+        self.latency = value
+        return self

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

@@ -0,0 +1,56 @@
+"""
+This module defines offset constraints in AUTOSAR timing specifications.
+
+Offset constraints specify timing offsets relative to a reference event or time base.
+
+Classes:
+    OffsetTimingConstraint: Specifies timing offset requirements
+"""
+
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import (
+    TimeValue,
+)
+from armodel.models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingConstraint import TimingConstraint
+
+
+class OffsetTimingConstraint(TimingConstraint):
+    """
+    Specifies timing offset requirements in AUTOSAR timing specifications.
+    This constraint defines a time offset relative to a reference event
+    or time base.
+    """
+
+    def __init__(self, parent, short_name: str):
+        """
+        Initializes the OffsetTimingConstraint with a parent and short name.
+
+        Args:
+            parent: The parent ARObject that contains this offset constraint
+            short_name: The unique short name of this offset constraint
+        """
+        super().__init__(parent, short_name)
+
+        # Timing offset value
+        self.offset: TimeValue = None
+
+    def getOffset(self):
+        """
+        Gets the timing offset.
+
+        Returns:
+            TimeValue: The timing offset
+        """
+        return self.offset
+
+    def setOffset(self, value):
+        """
+        Sets the timing offset.
+
+        Args:
+            value: The timing offset to set
+
+        Returns:
+            self for method chaining
+        """
+        self.offset = value
+        return self

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

@@ -0,0 +1,57 @@
+"""
+This module defines synchronization point constraints in AUTOSAR timing specifications.
+
+Synchronization point constraints specify synchronization requirements
+between distributed AUTOSAR elements.
+
+Classes:
+    SynchronizationPointConstraint: Specifies synchronization point requirements
+"""
+
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import (
+    String,
+)
+from armodel.models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingConstraint import TimingConstraint
+
+
+class SynchronizationPointConstraint(TimingConstraint):
+    """
+    Specifies synchronization point requirements in AUTOSAR timing specifications.
+    This constraint defines synchronization requirements between distributed
+    AUTOSAR elements.
+    """
+
+    def __init__(self, parent, short_name: str):
+        """
+        Initializes the SynchronizationPointConstraint with a parent and short name.
+
+        Args:
+            parent: The parent ARObject that contains this synchronization point constraint
+            short_name: The unique short name of this synchronization point constraint
+        """
+        super().__init__(parent, short_name)
+
+        # Synchronization point identifier
+        self.synchronization_point: String = None
+
+    def getSynchronizationPoint(self):
+        """
+        Gets the synchronization point identifier.
+
+        Returns:
+            String: The synchronization point identifier
+        """
+        return self.synchronization_point
+
+    def setSynchronizationPoint(self, value):
+        """
+        Sets the synchronization point identifier.
+
+        Args:
+            value: The synchronization point identifier to set
+
+        Returns:
+            self for method chaining
+        """
+        self.synchronization_point = value
+        return self

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

@@ -0,0 +1,117 @@
+"""
+This module defines synchronization timing constraints in AUTOSAR timing specifications.
+
+Synchronization timing constraints specify timing requirements for
+synchronization between AUTOSAR elements.
+
+Classes:
+    SynchronizationTimingConstraint: Specifies synchronization timing requirements
+    SynchronizationTypeEnum: Enumeration for synchronization types
+    EventOccurrenceKindEnum: Enumeration for event occurrence kinds
+"""
+
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import (
+    AREnum,
+)
+from armodel.models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingConstraint import TimingConstraint
+
+
+class SynchronizationTypeEnum(AREnum):
+    """
+    Enumeration for synchronization types.
+    """
+
+    HARD_SYNCHRONIZATION = "hard-synchronization"
+    SOFT_SYNCHRONIZATION = "soft-synchronization"
+    NO_SYNCHRONIZATION = "no-synchronization"
+
+    def __init__(self):
+        super().__init__((
+            SynchronizationTypeEnum.HARD_SYNCHRONIZATION,
+            SynchronizationTypeEnum.SOFT_SYNCHRONIZATION,
+            SynchronizationTypeEnum.NO_SYNCHRONIZATION,
+        ))
+
+
+class EventOccurrenceKindEnum(AREnum):
+    """
+    Enumeration for event occurrence kinds.
+    """
+
+    START = "start"
+    END = "end"
+    START_AND_END = "start-and-end"
+
+    def __init__(self):
+        super().__init__((
+            EventOccurrenceKindEnum.START,
+            EventOccurrenceKindEnum.END,
+            EventOccurrenceKindEnum.START_AND_END,
+        ))
+
+
+class SynchronizationTimingConstraint(TimingConstraint):
+    """
+    Specifies synchronization timing requirements in AUTOSAR timing specifications.
+    This constraint defines timing requirements for synchronization between
+    AUTOSAR elements.
+    """
+
+    def __init__(self, parent, short_name: str):
+        """
+        Initializes the SynchronizationTimingConstraint with a parent and short name.
+
+        Args:
+            parent: The parent ARObject that contains this synchronization timing constraint
+            short_name: The unique short name of this synchronization timing constraint
+        """
+        super().__init__(parent, short_name)
+
+        # Type of synchronization
+        self.synchronization_type: SynchronizationTypeEnum = None
+        # Event occurrence kind
+        self.event_occurrence_kind: EventOccurrenceKindEnum = None
+
+    def getSynchronizationType(self):
+        """
+        Gets the synchronization type.
+
+        Returns:
+            SynchronizationTypeEnum: The synchronization type
+        """
+        return self.synchronization_type
+
+    def setSynchronizationType(self, value):
+        """
+        Sets the synchronization type.
+
+        Args:
+            value: The synchronization type to set
+
+        Returns:
+            self for method chaining
+        """
+        self.synchronization_type = value
+        return self
+
+    def getEventOccurrenceKind(self):
+        """
+        Gets the event occurrence kind.
+
+        Returns:
+            EventOccurrenceKindEnum: The event occurrence kind
+        """
+        return self.event_occurrence_kind
+
+    def setEventOccurrenceKind(self, value):
+        """
+        Sets the event occurrence kind.
+
+        Args:
+            value: The event occurrence kind to set
+
+        Returns:
+            self for method chaining
+        """
+        self.event_occurrence_kind = value
+        return self