space_packet_parser.xtce.comparisons ==================================== .. py:module:: space_packet_parser.xtce.comparisons .. autoapi-nested-parse:: Matching logical objects Classes ------- .. autoapisummary:: space_packet_parser.xtce.comparisons.MatchCriteria space_packet_parser.xtce.comparisons.Comparison space_packet_parser.xtce.comparisons.Condition space_packet_parser.xtce.comparisons.Anded space_packet_parser.xtce.comparisons.Ored space_packet_parser.xtce.comparisons.BooleanExpression space_packet_parser.xtce.comparisons.DiscreteLookup Module Contents --------------- .. py:class:: MatchCriteria Bases: :py:obj:`space_packet_parser.common.AttrComparable`, :py:obj:`space_packet_parser.common.XmlObject` This class stores criteria for performing logical operations based on parameter values Classes that inherit from this ABC include those that represent , , and (not supported) .. py:attribute:: _valid_operators .. py:method:: evaluate(packet: space_packet_parser.SpacePacket, current_parsed_value: Optional[Union[int, float]] = None) -> bool :abstractmethod: Evaluate match criteria down to a boolean. :param packet: Packet data used to evaluate truthyness of the match criteria. :type packet: space_packet_parser.SpacePacket :param current_parsed_value: Uncalibrated value that is currently being matched (e.g. as a candidate for calibration). Used to resolve comparisons that reference their own raw value as a condition. :type current_parsed_value: any, Optional :returns: Truthyness of this match criteria based on previously parsed values. :rtype: bool .. py:class:: Comparison(required_value: str, referenced_parameter: str, operator: str = '==', use_calibrated_value: bool = True) Bases: :py:obj:`MatchCriteria` .. py:attribute:: required_value .. py:attribute:: referenced_parameter .. py:attribute:: operator :value: '==' .. py:attribute:: use_calibrated_value :value: True .. py:method:: __repr__() .. py:method:: _validate() Validate state as logically consistent. :rtype: None .. py:method:: from_xml(element: lxml.etree.Element, *, tree: Optional[lxml.etree.Element] = None, parameter_lookup: Optional[dict[str, any]] = None, parameter_type_lookup: Optional[dict[str, any]] = None, container_lookup: Optional[dict[str, any]] = None) -> Comparison :classmethod: Create :param element: XML element :type element: ElementTree.Element :param tree: Ignored :type tree: Optional[ElementTree.Element] :param parameter_lookup: Ignored :type parameter_lookup: Optional[dict] :param parameter_type_lookup: Ignored :type parameter_type_lookup: Optional[dict] :param container_lookup: Ignored :type container_lookup: Optional[dict[str, SequenceContainer]] :rtype: Comparison .. py:method:: to_xml(*, elmaker: lxml.builder.ElementMaker) -> lxml.etree.Element Create a Comparison XML element :param elmaker: Element factory with predefined namespace :type elmaker: ElementMaker :rtype: ElementTree.Element .. py:method:: evaluate(packet: space_packet_parser.SpacePacket, current_parsed_value: Optional[Union[int, float]] = None) -> bool Evaluate comparison down to a boolean. If the parameter to compare is not present in the parsed_data dict, we assume that we are comparing against the current raw value in current_parsed_value. :param packet: Packet data used to evaluate truthyness of the match criteria. :type packet: space_packet_parser.SpacePacket :param current_parsed_value: Optional. Uncalibrated value that is currently a candidate for calibration and so has not yet been added to the packet. Used to resolve calibrator conditions that reference their own raw value as a comparate. :type current_parsed_value: Union[int, float] :returns: Truthyness of this match criteria based on previously parsed values. :rtype: bool .. py:class:: Condition(left_param: str, operator: str, *, right_param: Optional[str] = None, right_value: Optional[Any] = None, left_use_calibrated_value: bool = True, right_use_calibrated_value: bool = True) Bases: :py:obj:`MatchCriteria` Note: This xtce model doesn't actually inherit from MatchCriteria in the UML model, but it's functionally close enough that we inherit the class here. .. py:attribute:: left_param .. py:attribute:: right_param :value: None .. py:attribute:: right_value :value: None .. py:attribute:: operator .. py:attribute:: right_use_calibrated_value :value: True .. py:attribute:: left_use_calibrated_value :value: True .. py:method:: __repr__() .. py:method:: _validate() Check that the instantiated object actually makes logical sense. :rtype: None .. py:method:: _parse_parameter_instance_ref(element: lxml.etree.Element) :staticmethod: Parse an xtce:ParameterInstanceRef element :param element: xtce:ParameterInstanceRef element :type element: ElementTree.Element :returns: * **parameter_name** (*str*) -- Name of referenced parameter * **use_calibrated_value** (*bool*) -- Whether to use the calibrated form of the referenced parameter .. py:method:: from_xml(element: lxml.etree.Element, *, tree: Optional[lxml.etree.Element] = None, parameter_lookup: Optional[dict[str, any]] = None, parameter_type_lookup: Optional[dict[str, any]] = None, container_lookup: Optional[dict[str, any]] = None) -> Condition :classmethod: Classmethod to create a Condition object from an XML element. :param element: XML element :type element: ElementTree.Element :param tree: Ignored :type tree: Optional[ElementTree.Element] :param parameter_lookup: Ignored :type parameter_lookup: Optional[dict] :param parameter_type_lookup: Ignored :type parameter_type_lookup: Optional[dict] :param container_lookup: Ignored :type container_lookup: Optional[dict[str, SequenceContainer]] :rtype: cls .. py:method:: to_xml(*, elmaker: lxml.builder.ElementMaker) -> lxml.etree.Element Create a Condition XML element :param elmaker: Element factory with predefined namespace :type elmaker: ElementMaker :rtype: ElementTree.Element .. py:method:: evaluate(packet: space_packet_parser.SpacePacket, current_parsed_value: Optional[Union[int, float]] = None) -> bool Evaluate match criteria down to a boolean. :param packet: Packet data used to evaluate truthyness of the match criteria. :type packet: space_packet_parser.SpacePacket :param current_parsed_value: Ignored. :type current_parsed_value: Optional[Union[int, float]] :returns: Truthyness of this match criteria based on previously parsed values. :rtype: bool .. py:class:: Anded Bases: :py:obj:`namedtuple`\ (\ :py:obj:`'Anded'`\ , [\ :py:obj:`'conditions'`\ , :py:obj:`'ors'`\ ]\ ) Tuple object for AND operations in BooleanExpression .. py:method:: __repr__() Return repr(self). .. py:class:: Ored Bases: :py:obj:`namedtuple`\ (\ :py:obj:`'Ored'`\ , [\ :py:obj:`'conditions'`\ , :py:obj:`'ands'`\ ]\ ) Tuple object for OR operations in BooleanExpression .. py:method:: __repr__() Return repr(self). .. py:class:: BooleanExpression(expression: Union[Condition, Anded, Ored]) Bases: :py:obj:`MatchCriteria` .. py:attribute:: expression .. py:method:: __repr__() .. py:method:: from_xml(element: lxml.etree.Element, *, tree: Optional[lxml.etree.Element] = None, parameter_lookup: Optional[dict[str, any]] = None, parameter_type_lookup: Optional[dict[str, any]] = None, container_lookup: Optional[dict[str, any]] = None) -> BooleanExpression :classmethod: Abstract classmethod to create a match criteria object from an XML element. :param element: XML element :type element: ElementTree.Element :param tree: Ignored :type tree: Optional[ElementTree.Element] :param parameter_lookup: Ignored :type parameter_lookup: Optional[dict] :param parameter_type_lookup: Ignored :type parameter_type_lookup: Optional[dict] :param container_lookup: Ignored :type container_lookup: Optional[dict[str, SequenceContainer]] :rtype: BooleanExpression .. py:method:: evaluate(packet: space_packet_parser.SpacePacket, current_parsed_value: Optional[Union[int, float]] = None) -> bool Evaluate the criteria in the BooleanExpression down to a single boolean. :param packet: Packet data used to evaluate truthyness of the match criteria. :type packet: space_packet_parser.SpacePacket :param current_parsed_value: Ignored. :type current_parsed_value: Optional[Union[int, float]] :returns: Truthyness of this match criteria based on previously parsed values. :rtype: bool .. py:method:: to_xml(*, elmaker: lxml.builder.ElementMaker) -> lxml.etree.Element Create a Condition XML element :param elmaker: Element factory with predefined namespace :type elmaker: ElementMaker :rtype: ElementTree.Element .. py:class:: DiscreteLookup(match_criteria: list[Comparison], lookup_value: Union[int, float]) Bases: :py:obj:`space_packet_parser.common.AttrComparable`, :py:obj:`space_packet_parser.common.XmlObject` .. py:attribute:: match_criteria .. py:attribute:: lookup_value .. py:method:: from_xml(element: lxml.etree.Element, *, tree: Optional[lxml.etree.ElementTree] = None, parameter_lookup: Optional[dict[str, any]] = None, parameter_type_lookup: Optional[dict[str, any]] = None, container_lookup: Optional[dict[str, any]] = None) -> DiscreteLookup :classmethod: Create a DiscreteLookup object from an XML element :param element: XML element from which to parse the DiscreteLookup object. :type element: ElementTree.Element :param tree: Ignored :type tree: Optional[ElementTree.Element] :param parameter_lookup: Ignored :type parameter_lookup: Optional[dict] :param parameter_type_lookup: Ignored :type parameter_type_lookup: Optional[dict] :param container_lookup: Ignored :type container_lookup: Optional[dict[str, SequenceContainer]] :rtype: DiscreteLookup .. py:method:: to_xml(*, elmaker: lxml.builder.ElementMaker) -> lxml.etree.Element Create a DiscreteLookup XML element :param elmaker: ElementMaker factory :type elmaker: ElementMaker :rtype: ElementTree.Element .. py:method:: evaluate(packet: space_packet_parser.SpacePacket, current_parsed_value: Optional[Union[int, float]] = None) -> Any Evaluate the lookup to determine if it is valid. :param packet: Packet data used to evaluate truthyness of the match criteria. :type packet: space_packet_parser.SpacePacket :param current_parsed_value: If referenced parameter in criterion isn't in the packet, we assume we are comparing against this currently parsed value. :type current_parsed_value: Optional[Union[int, float]] :returns: Return the lookup value if the match criteria evaluate true. Return None otherwise. :rtype: any