tdl-xoa-driver 1.0.0b1__py3-none-any.whl

xoa_driver/internals/commands/ped_commands.py

@@ -0,0 +1,1034 @@
+from __future__ import annotations
+from dataclasses import dataclass
+import typing
+import functools
+
+from xoa_driver.internals.core.builders import (
+    build_get_request,
+    build_set_request
+)
+from xoa_driver.internals.core import interfaces
+from xoa_driver.internals.core.token import Token
+from xoa_driver.internals.core.transporter.registry import register_command
+from xoa_driver.internals.core.transporter.protocol.payload import (
+    field,
+    RequestBodyStruct,
+    ResponseBodyStruct,
+    XmpByte,
+    XmpInt,
+    XmpLong,
+)
+from .enums import OnOff
+
+
+@register_command
+@dataclass
+class PED_SCHEDULE:
+    """
+    Configure the impairment scheduler function.  The configuration of the scheduler
+    depends on the kind of distribution to schedule:      (1) Burst distributions:
+    "Fixed Burst" and "Accumulate and Burst".      (2) Non-Burst distributions: All
+    others.  For burst distributions, the scheduler can be configured for "One-shot"
+    operation or "Repeat Operation".  When running in "Repeat Operation" the "Repeat
+    Period" must be configured. For non-burst distributions,  the scheduler can be
+    configured operate in either "Continuous" or "Repeat Period" modes.  When
+    running in "Repeat Period" configuration of "Duration" and "Repeat Period" is
+    required.
+    """
+
+    code: typing.ClassVar[int] = 1611
+    pushed: typing.ClassVar[bool] = True
+
+    _connection: 'interfaces.IConnection'
+    _module: int
+    _port: int
+    _flow_xindex: int
+    _impairment_type_xindex: int
+
+    class GetDataAttr(ResponseBodyStruct):
+        duration: int = field(XmpInt())
+        """integer, specifies the "on" period. Units = multiples of 10 ms (range 1 to 65535), default is 1"""
+        period: int = field(XmpInt())
+        """integer, specifies the "total" period. Units = multiples of 10 ms (range 0 to 65535), default is 0"""
+
+    class SetDataAttr(RequestBodyStruct):
+        duration: int = field(XmpInt())
+        """integer, specifies the "on" period. Units = multiples of 10 ms (range 1 to 65535), default is 1"""
+        period: int = field(XmpInt())
+        """integer, specifies the "total" period. Units = multiples of 10 ms (range 0 to 65535), default is 0"""
+
+    def get(self) -> Token[GetDataAttr]:
+        """Get the impairment scheduler configuration.
+
+        :return: the impairment scheduler configuration
+        :rtype: PED_SCHEDULE.GetDataAttr
+        """
+
+        return Token(self._connection, build_get_request(self, module=self._module, port=self._port, indices=[self._flow_xindex, self._impairment_type_xindex]))
+
+    def set(self, duration: int, period: int) -> Token[None]:
+        """Set the impairment scheduler configuration.
+
+        :param duration: specifies the "on" period. Units = multiples of 10 ms (range 1 to 65535), default is 1
+        :type duration: int
+        :param period: specifies the "total" period. Units = multiples of 10 ms (range 0 to 65535), default is 0
+        :type period: int
+        """
+
+        return Token(
+            self._connection,
+            build_set_request(
+                self,
+                module=self._module,
+                port=self._port,
+                indices=[self._flow_xindex, self._impairment_type_xindex],
+                duration=duration,
+                period=period
+            )
+        )
+
+
+@register_command
+@dataclass
+class PED_ONESHOTSTATUS:
+    """
+    Retrieves the one-shot completion status.
+
+    .. note::
+
+        The return value is only valid, if the configured distribution is either accumulate & burst (DELAY) or fixed burst (non-DELAY).
+        
+    """
+
+    code: typing.ClassVar[int] = 1612
+    pushed: typing.ClassVar[bool] = False
+
+    _connection: 'interfaces.IConnection'
+    _module: int
+    _port: int
+    _flow_xindex: int
+    _impairment_type_xindex: int
+
+    class GetDataAttr(ResponseBodyStruct):
+        one_shot_status: int = field(XmpByte())
+        """byte, specifies the status."""
+
+    def get(self) -> Token[GetDataAttr]:
+        """Get the one-shot completion status.
+
+        :return: the one-shot completion status
+        :rtype: PED_ONESHOTSTATUS.GetDataAttr
+        """
+
+        return Token(self._connection, build_get_request(self, module=self._module, port=self._port, indices=[self._flow_xindex, self._impairment_type_xindex]))
+
+
+@register_command
+@dataclass
+class PED_OFF:
+    """Configure Impairments Distribution to OFF. Assigning a different distribution than OFF to an impairment
+    will activate the impairment. To de-activate the impairment assign distribution OFF.
+    """
+
+    code: typing.ClassVar[int] = 1620
+    pushed: typing.ClassVar[bool] = False
+
+    _connection: 'interfaces.IConnection'
+    _module: int
+    _port: int
+    _flow_xindex: int
+    _impairment_type_xindex: int
+
+    class SetDataAttr(RequestBodyStruct):
+        pass
+
+    def set(self) -> Token[None]:
+        """Configure Impairments Distribution to OFF. Assigning a different distribution than OFF to an impairment
+        will activate the impairment. To de-activate the impairment assign distribution OFF.
+        """
+
+        return Token(self._connection, build_set_request(self, module=self._module, port=self._port, indices=[self._flow_xindex, self._impairment_type_xindex]))
+
+
+@register_command
+@dataclass
+class PED_FIXED:
+    """
+    Configuration of Fixed Rate distribution. This is predictable distribution with
+    nearly equal distance between impairments, to match the configured probability.
+
+    .. note::
+
+        In case of misordering, a special limit applies, probability * (depth + 1) should be less than 1000000.
+
+    """
+
+    code: typing.ClassVar[int] = 1621
+    pushed: typing.ClassVar[bool] = False
+
+    _connection: 'interfaces.IConnection'
+    _module: int
+    _port: int
+    _flow_xindex: int
+    _impairment_type_xindex: int
+
+    class GetDataAttr(ResponseBodyStruct):
+        probability: int = field(XmpInt())
+        """integer, specifies the fixed probability in ppm. Default value is 0."""
+
+    class SetDataAttr(RequestBodyStruct):
+        probability: int = field(XmpInt())
+        """integer, specifies the fixed probability in ppm. Default value is 0."""
+
+    def get(self) -> Token[GetDataAttr]:
+        """Get the probability of a Fixed Rate distribution.
+
+        :return: the fixed probability in ppm. Default value is 0.
+        :rtype: PED_FIXED.GetDataAttr
+        """
+
+        return Token(self._connection, build_get_request(self, module=self._module, port=self._port, indices=[self._flow_xindex, self._impairment_type_xindex]))
+
+    def set(self, probability: int) -> Token[None]:
+        """Set the probability of a Fixed Rate distribution.
+
+        :param probability: the fixed probability in ppm. Default value is 0.
+        :type probability: int
+        """
+
+        return Token(
+            self._connection,
+            build_set_request(
+                self,
+                module=self._module,
+                port=self._port,
+                indices=[self._flow_xindex, self._impairment_type_xindex],
+                probability=probability
+            )
+        )
+
+
+@register_command
+@dataclass
+class PED_RANDOM:
+    """
+    Configuration of Random Rate distribution. Packets are impaired randomly based
+    on a per packet probability. This way the impaired fraction of packets will be
+    equal to the configured probability over time. Random probability in ppm (i.e. 1
+    means 0.0001%)
+    """
+
+    code: typing.ClassVar[int] = 1622
+    pushed: typing.ClassVar[bool] = False
+
+    _connection: 'interfaces.IConnection'
+    _module: int
+    _port: int
+    _flow_xindex: int
+    _impairment_type_xindex: int
+
+    class GetDataAttr(ResponseBodyStruct):
+        probability: int = field(XmpInt())
+        """integer, specifies the random probability in ppm. Default value is 0."""
+
+    class SetDataAttr(RequestBodyStruct):
+        probability: int = field(XmpInt())
+        """integer, specifies the random probability in ppm. Default value is 0."""
+
+    def get(self) -> Token[GetDataAttr]:
+        """Get the probability of a Random Rate distribution.
+
+        :return: specifies the random probability in ppm. Default value is 0.
+        :rtype: PED_RANDOM.GetDataAttr
+        """
+
+        return Token(self._connection, build_get_request(self, module=self._module, port=self._port, indices=[self._flow_xindex, self._impairment_type_xindex]))
+
+    def set(self, probability: int) -> Token[None]:
+        """Set the probability of a Random Rate distribution.
+
+        :param probability: specifies the random probability in ppm. Default value is 0.
+        :type probability: int
+        """
+
+        return Token(
+            self._connection,
+            build_set_request(
+                self,
+                module=self._module,
+                port=self._port,
+                indices=[self._flow_xindex, self._impairment_type_xindex],
+                probability=probability
+            )
+        )
+
+
+@register_command
+@dataclass
+class PED_BER:
+    """
+    Configuration of Bit Error Rate distribution.
+    """
+
+    code: typing.ClassVar[int] = 1623
+    pushed: typing.ClassVar[bool] = False
+
+    _connection: 'interfaces.IConnection'
+    _module: int
+    _port: int
+    _flow_xindex: int
+    _impairment_type_xindex: int
+
+    class GetDataAttr(ResponseBodyStruct):
+        coef: int = field(XmpInt())
+        """integer, specifies the coefficient for BER. Default value: 1 (Range is 1 to 9)."""
+        exp: int = field(XmpInt())
+        """integer, specifies the exponent for BER. Default value: -10 (Range is -18 to -1)."""
+
+    class SetDataAttr(RequestBodyStruct):
+        coef: int = field(XmpInt())
+        """integer, specifies the coefficient for BER. Default value: 1 (Range is 1 to 9)."""
+        exp: int = field(XmpInt())
+        """integer, specifies the exponent for BER. Default value: -10 (Range is -18 to -1)."""
+
+    def get(self) -> Token[GetDataAttr]:
+        """Get the configuration of Bit Error Rate distribution.
+
+        :return: the configuration of Bit Error Rate distribution
+        :rtype: PED_BER.GetDataAttr
+        """
+
+        return Token(self._connection, build_get_request(self, module=self._module, port=self._port, indices=[self._flow_xindex, self._impairment_type_xindex]))
+
+    def set(self, coef: int, exp: int) -> Token[None]:
+        """Set the configuration of Bit Error Rate distribution.
+
+        :param coef: specifies the coefficient for BER. Default value: 1 (Range is 1 to 9).
+        :type coef: int
+        :param exp: specifies the exponent for BER. Default value: -10 (Range is -18 to -1).
+        :type exp: int
+        """
+
+        return Token(self._connection, build_set_request(self, module=self._module, port=self._port, indices=[self._flow_xindex, self._impairment_type_xindex], coef=coef, exp=exp))
+
+
+@register_command
+@dataclass
+class PED_FIXEDBURST:
+    """
+    Configuration of Fixed Burst distribution.
+
+    .. note::
+
+        In case of ``_impairment_type_xindex`` = ``MISO``, burst size is fixed to 1.
+
+    """
+
+    code: typing.ClassVar[int] = 1624
+    pushed: typing.ClassVar[bool] = False
+
+    _connection: 'interfaces.IConnection'
+    _module: int
+    _port: int
+    _flow_xindex: int
+    _impairment_type_xindex: int
+
+    class GetDataAttr(ResponseBodyStruct):
+        burst_size: int = field(XmpInt())
+        """integer, specifies the burst size (Range 1 - 16383). Default value = 1."""
+
+    class SetDataAttr(RequestBodyStruct):
+        burst_size: int = field(XmpInt())
+        """integer, specifies the burst size (Range 1 - 16383). Default value = 1."""
+
+    def get(self) -> Token[GetDataAttr]:
+        """Get the configuration of Fixed Burst distribution.
+
+        :return: configuration of Fixed Burst distribution.
+        :rtype: PED_FIXEDBURST.GetDataAttr
+        """
+
+        return Token(self._connection, build_get_request(self, module=self._module, port=self._port, indices=[self._flow_xindex, self._impairment_type_xindex]))
+
+    def set(self, burst_size: int) -> Token[None]:
+        """Set the configuration of Fixed Burst distribution.
+
+        :param burst_size: specifies the burst size (Range 1 - 16383). Default value = 1.
+        :type burst_size: int
+        """
+
+        return Token(
+            self._connection,
+            build_set_request(self, module=self._module, port=self._port, indices=[self._flow_xindex, self._impairment_type_xindex], burst_size=burst_size)
+        )
+
+
+@register_command
+@dataclass
+class PED_RANDOMBURST:
+    """
+    Configuration of Random Burst distribution.
+    """
+
+    code: typing.ClassVar[int] = 1625
+    pushed: typing.ClassVar[bool] = False
+
+    _connection: 'interfaces.IConnection'
+    _module: int
+    _port: int
+    _flow_xindex: int
+    _impairment_type_xindex: int
+
+    class GetDataAttr(ResponseBodyStruct):
+        minimum: int = field(XmpInt())
+        """integer, specifies minimum burst size. Default value: 0 (Range 0 to 65535)"""
+        maximum: int = field(XmpInt())
+        """integer, specifies maximum burst size. Default value: 0 (Range 0 to 65535)"""
+        probability: int = field(XmpInt())
+        """integer, specifies the per packet probability of initiating a burst in ppm. Default value: 0."""
+
+    class SetDataAttr(RequestBodyStruct):
+        minimum: int = field(XmpInt())
+        """integer, specifies minimum burst size. Default value: 0 (Range 0 to 65535)"""
+        maximum: int = field(XmpInt())
+        """integer, specifies maximum burst size. Default value: 0 (Range 0 to 65535)"""
+        probability: int = field(XmpInt())
+        """integer, specifies the per packet probability of initiating a burst in ppm. Default value: 0."""
+
+    def get(self) -> Token[GetDataAttr]:
+        """Get the configuration of Random Burst distribution.
+
+        :return: configuration of Random Burst distribution.
+        :rtype: PED_RANDOMBURST.GetDataAttr
+        """
+
+        return Token(self._connection, build_get_request(self, module=self._module, port=self._port, indices=[self._flow_xindex, self._impairment_type_xindex]))
+
+    def set(self, minimum: int, maximum: int, probability: int) -> Token[None]:
+        """Set the configuration of Random Burst distribution.
+
+        :param minimum: specifies minimum burst size. Default value: 0 (Range 0 to 65535)
+        :type minimum: int
+        :param maximum: specifies maximum burst size. Default value: 0 (Range 0 to 65535)
+        :type maximum: int
+        :param probability: specifies the per packet probability of initiating a burst in ppm. Default value: 0.
+        :type probability: int
+        """
+
+        return Token(
+            self._connection,
+            build_set_request(
+                self,
+                module=self._module,
+                port=self._port,
+                indices=[self._flow_xindex, self._impairment_type_xindex],
+                minimum=minimum,
+                maximum=maximum,
+                probability=probability
+            )
+        )
+
+
+@register_command
+@dataclass
+class PED_GE:
+    """
+    Configuration of Gilbert-Elliot distribution.
+    """
+
+    code: typing.ClassVar[int] = 1626
+    pushed: typing.ClassVar[bool] = False
+
+    _connection: 'interfaces.IConnection'
+    _module: int
+    _port: int
+    _flow_xindex: int
+    _impairment_type_xindex: int
+
+    class GetDataAttr(ResponseBodyStruct):
+        good_state_prob: int = field(XmpInt())
+        """integer, specifies the good state probability in ppm. Default value: 0."""
+        good_state_trans_prob: int = field(XmpInt())
+        """integer, specifies the good state transition probability in ppm. Default value: 0."""
+        bad_state_prob: int = field(XmpInt())
+        """integer, specifies the bad state probability in ppm. Default value: 0."""
+        bad_state_trans_prob: int = field(XmpInt())
+        """integer, specifies the bad state transition probability in ppm. Default value: 0."""
+
+    class SetDataAttr(RequestBodyStruct):
+        good_state_prob: int = field(XmpInt())
+        """integer, specifies the good state probability in ppm. Default value: 0."""
+        good_state_trans_prob: int = field(XmpInt())
+        """integer, specifies the good state transition probability in ppm. Default value: 0."""
+        bad_state_prob: int = field(XmpInt())
+        """integer, specifies the bad state probability in ppm. Default value: 0."""
+        bad_state_trans_prob: int = field(XmpInt())
+        """integer, specifies the bad state transition probability in ppm. Default value: 0."""
+
+    def get(self) -> Token[GetDataAttr]:
+        """Get the configuration of Gilbert-Elliot distribution.
+
+        :return: the configuration of Gilbert-Elliot distribution.
+        :rtype: PED_GE.GetDataAttr
+        """
+
+        return Token(self._connection, build_get_request(self, module=self._module, port=self._port, indices=[self._flow_xindex, self._impairment_type_xindex]))
+
+    def set(self, good_state_prob: int, good_state_trans_prob: int, bad_state_prob: int, bad_state_trans_prob: int) -> Token[None]:
+        """Set the configuration of Gilbert-Elliot distribution.
+
+        :param good_state_prob: specifies the good state probability in ppm. Default value: 0.
+        :type good_state_prob: int
+        :param good_state_trans_prob: specifies the good state transition probability in ppm. Default value: 0.
+        :type good_state_trans_prob: int
+        :param bad_state_prob: specifies the bad state probability in ppm. Default value: 0.
+        :type bad_state_prob: int
+        :param bad_state_trans_prob: specifies the bad state transition probability in ppm. Default value: 0.
+        :type bad_state_trans_prob: int
+        """
+
+        return Token(
+            self._connection,
+            build_set_request(
+                self,
+                module=self._module,
+                port=self._port,
+                indices=[self._flow_xindex, self._impairment_type_xindex],
+                good_state_prob=good_state_prob,
+                good_state_trans_prob=good_state_trans_prob,
+                bad_state_prob=bad_state_prob,
+                bad_state_trans_prob=bad_state_trans_prob
+            )
+        )
+
+
+@register_command
+@dataclass
+class PED_UNI:
+    """
+    Configuration of Uniform distribution.
+
+    .. note::
+
+        If minimum is less than minimum , value is set to minimum. If minimum is greater than maximum, value is set to maximum.
+
+    """
+
+    code: typing.ClassVar[int] = 1627
+    pushed: typing.ClassVar[bool] = False
+
+    _connection: 'interfaces.IConnection'
+    _module: int
+    _port: int
+    _flow_xindex: int
+    _impairment_type_xindex: int
+
+    class GetDataAttr(ResponseBodyStruct):
+        minimum: int = field(XmpLong())
+        """long, in case of iid != DELAY, specifies the minimum no. of packets. Default value: 0 (Range 0 to 4194288).
+        In case of iid = DELAY, specifies the minimum latency limit. Unit is nanosecond (must be multiples of 100 ns). Default value: minimum latency.
+        """
+        maximum: int = field(XmpLong())
+        """long, in case of iid != DELAY, specifies the maximum no. of packets. Default value: 0 (Range 0 to 4194288).
+        In case of iid = DELAY, specifies the maximum latency limit. Unit is nanosecond (must be multiples of 100 ns). Default value: minimum latency.
+        """
+
+    class SetDataAttr(RequestBodyStruct):
+        minimum: int = field(XmpLong())
+        """long, in case of iid != DELAY, specifies the minimum no. of packets. Default value: 0 (Range 0 to 4194288).
+        In case of iid = DELAY, specifies the minimum latency limit. Unit is nanosecond (must be multiples of 100 ns). Default value: minimum latency.
+        """
+        maximum: int = field(XmpLong())
+        """long, in case of iid != DELAY, specifies the maximum no. of packets. Default value: 0 (Range 0 to 4194288).
+        In case of iid = DELAY, specifies the maximum latency limit. Unit is nanosecond (must be multiples of 100 ns). Default value: minimum latency.
+        """
+
+    def get(self) -> Token[GetDataAttr]:
+        """Get the configuration of Uniform distribution.
+
+        :return: the configuration of Uniform distribution.
+        :rtype: PED_UNI.GetDataAttr
+        """
+
+        return Token(self._connection, build_get_request(self, module=self._module, port=self._port, indices=[self._flow_xindex, self._impairment_type_xindex]))
+
+    def set(self, minimum: int, maximum: int) -> Token[None]:
+        """Set the configuration of Uniform distribution.
+
+        :param minimum: in case of iid != DELAY, specifies the minimum no. of packets. Default value: 0 (Range 0 to 4194288).
+            In case of iid = DELAY, specifies the minimum latency limit. Unit is nanosecond (must be multiples of 100 ns). Default value: minimum latency.
+        :type minimum: int
+        :param maximum: in case of iid != DELAY, specifies the maximum no. of packets. Default value: 0 (Range 0 to 4194288).
+            In case of iid = DELAY, specifies the maximum latency limit. Unit is nanosecond (must be multiples of 100 ns). Default value: minimum latency.
+        :type maximum: int
+        """
+
+        return Token(
+            self._connection,
+            build_set_request(self, module=self._module, port=self._port, indices=[self._flow_xindex, self._impairment_type_xindex], minimum=minimum, maximum=maximum)
+        )
+
+
+@register_command
+@dataclass
+class PED_GAUSS:
+    """
+    Configuration of Gaussian distribution.
+
+    .. note::
+
+        In case of ``_impairment_type_xindex != DELAY``:
+            (1) mean plus 3 times standard deviation should be less than or equal to max allowed (4194288).
+            (2) mean should always be at least 3 times the standard deviation, this to ensure that the impairment distance is always positive.
+
+        In case of ``_impairment_type_xindex = DELAY``:
+            (1) mean plus 3 times standard deviation should be less than or equal to the maximum latency.
+            (2) mean minus 3 times the standard deviation should be greater than or equal to minimum latency.
+
+    """
+
+    code: typing.ClassVar[int] = 1628
+    pushed: typing.ClassVar[bool] = False
+
+    _connection: 'interfaces.IConnection'
+    _module: int
+    _port: int
+    _flow_xindex: int
+    _impairment_type_xindex: int
+
+    class GetDataAttr(ResponseBodyStruct):
+        mean: int = field(XmpLong())
+        """long, specifies the Gaussian mean. In case of iid != DELAY, specifies the Gaussian mean value as number of packets.Default value: 0 packets (Range 0 to 4194288).
+        In case of iid = DELAY, specifies the Gaussian mean value. Units is nanosecond (must be multiples of 100 ns).
+        """
+        std_deviation: int = field(XmpLong())
+        """long, specifies the Gaussian standard deviation. In case of iid != DELAY, specifies the standard deviation as number of packets.
+        Default value: 0 packets (Range 0 to 4194288). In case of iid = DELAY, specifies the the Gaussian standard deviation.
+        Units is nanosecond (must be multiples of 100 ns). Default value: 0 ns.
+        """
+
+    class SetDataAttr(RequestBodyStruct):
+        mean: int = field(XmpLong())
+        """long, specifies the Gaussian mean. In case of iid != DELAY, specifies the Gaussian mean value as number of packets.Default value: 0 packets (Range 0 to 4194288).
+        In case of iid = DELAY, specifies the Gaussian mean value. Units is nanosecond (must be multiples of 100 ns)."""
+        std_deviation: int = field(XmpLong())
+        """long, specifies the Gaussian standard deviation. In case of iid != DELAY, specifies the standard deviation as number of packets.
+        Default value: 0 packets (Range 0 to 4194288). In case of iid = DELAY, specifies the the Gaussian standard deviation.
+        Units is nanosecond (must be multiples of 100 ns). Default value: 0 ns.
+        """
+
+    def get(self) -> Token[GetDataAttr]:
+        """Get the configuration of Gaussian distribution.
+
+        :return: the configuration of Gaussian distribution
+        :rtype: PED_GAUSS.GetDataAttr
+        """
+
+        return Token(self._connection, build_get_request(self, module=self._module, port=self._port, indices=[self._flow_xindex, self._impairment_type_xindex]))
+
+    def set(self, mean: int, std_deviation: int) -> Token[None]:
+        """Set the configuration of Gaussian distribution.
+
+        :param mean: specifies the Gaussian mean.
+        :type mean: int
+        :param std_deviation: specifies the Gaussian standard deviation.
+        :type std_deviation: int
+        """
+
+        return Token(
+            self._connection,
+            build_set_request(self, module=self._module, port=self._port, indices=[self._flow_xindex, self._impairment_type_xindex], mean=mean, std_deviation=std_deviation)
+        )
+
+
+@register_command
+@dataclass
+class PED_POISSON:
+    """
+    Configuration of "Poisson" distribution.
+
+    .. note::
+
+        Standard deviation is derived from mean, i.e., standard deviation = SQRT(mean).
+
+        In case of ``_impairment_type_xindex != DELAY``, mean plus 3 times standard deviation should be less than or equal to max allowed (4194288).
+
+        In case of ``_impairment_type_xindex = DELAY``, mean plus 3 times standard deviation should be less than or equal to the maximum latency.
+
+    """
+
+    code: typing.ClassVar[int] = 1629
+    pushed: typing.ClassVar[bool] = False
+
+    _connection: 'interfaces.IConnection'
+    _module: int
+    _port: int
+    _flow_xindex: int
+    _impairment_type_xindex: int
+
+    class GetDataAttr(ResponseBodyStruct):
+        mean: int = field(XmpLong())
+        """long, specifies the Poisson mean value. In case of iid = DELAY specifies the Poisson mean. Unit is nanosecond (must be multiples of 100ns).
+        Default value: 0 ns. In case of iid != DELAY specifies the Poisson mean in number of packets packets. Default value: 9 packets (Range 0 to 4194288).
+        """
+
+    class SetDataAttr(RequestBodyStruct):
+        mean: int = field(XmpLong())
+        """long, specifies the Poisson mean value. In case of iid = DELAY specifies the Poisson mean. Unit is nanosecond (must be multiples of 100ns).
+        Default value: 0 ns. In case of iid != DELAY specifies the Poisson mean in number of packets packets. Default value: 9 packets (Range 0 to 4194288).
+        """
+
+    def get(self) -> Token[GetDataAttr]:
+        """Get the configuration of Poisson distribution.
+
+        :return: the configuration of Poisson distribution
+        :rtype: PED_POISSON.GetDataAttr
+        """
+
+        return Token(self._connection, build_get_request(self, module=self._module, port=self._port, indices=[self._flow_xindex, self._impairment_type_xindex]))
+
+    def set(self, mean: int) -> Token[None]:
+        """Set the configuration of Poisson distribution.
+
+        :param mean: specifies the Poisson mean value.
+        :type mean: int
+        """
+
+        return Token(self._connection, build_set_request(self, module=self._module, port=self._port, indices=[self._flow_xindex, self._impairment_type_xindex], mean=mean))
+
+
+@register_command
+@dataclass
+class PED_GAMMA:
+    """
+    Configuration of Gamma distribution.
+
+    .. note::
+
+        Mean and Standard deviation are calculated from Shape and Scale parameters and validation is performed using those.
+        standard deviation = [SQRT(shape * scale * scale)]mean = [shape * scale].
+
+        In case of ``_impairment_type_xindex != DELAY``,
+        (1) mean plus 4 times standard deviation should be less than or equal to max allowed(4194288).
+        (2)shape and scale should be greater than or equal to 0.
+
+        In case of ``_impairment_type_xindex = DELAY``, mean plus 4 times standard deviation should be less than or equal to the maximum latency.
+
+    """
+
+    code: typing.ClassVar[int] = 1630
+    pushed: typing.ClassVar[bool] = False
+
+    _connection: 'interfaces.IConnection'
+    _module: int
+    _port: int
+    _flow_xindex: int
+    _impairment_type_xindex: int
+
+    class GetDataAttr(ResponseBodyStruct):
+        shape: int = field(XmpLong())
+        """long, specifies the shape. Units: none. Default value: 0."""
+        scale: int = field(XmpLong())
+        """long, specifies the Gamma function scale parameter. In case of iid = DELAY, units: nanosecond
+        (must be multiples of 100 ns). Default value: 0 ns. In case of iid != DELAY, units: number of packets.Default value: 0 packets.
+        """
+
+    class SetDataAttr(RequestBodyStruct):
+        shape: int = field(XmpLong())
+        """long, specifies the shape. Units: none. Default value: 0."""
+        scale: int = field(XmpLong())
+        """long, specifies the Gamma function scale parameter. In case of iid = DELAY, units: nanosecond (must be multiples of 100 ns). Default value: 0 ns.
+        In case of iid != DELAY, units: number of packets.Default value: 0 packets.
+        """
+
+    def get(self) -> Token[GetDataAttr]:
+        """Get the configuration of Gamma distribution.
+
+        :return: the configuration of Gamma distribution
+        :rtype: PED_GAMMA.GetDataAttr
+        """
+
+        return Token(self._connection, build_get_request(self, module=self._module, port=self._port, indices=[self._flow_xindex, self._impairment_type_xindex]))
+
+    def set(self, shape: int, scale: int) -> Token[None]:
+        """Set the configuration of Gamma distribution.
+
+        :param shape: specifies the shape. Units: none. Default value: 0.
+        :type shape: int
+        :param scale: specifies the Gamma function scale parameter.
+        :type scale: int
+        """
+
+        return Token(
+            self._connection,
+            build_set_request(
+                self,
+                module=self._module,
+                port=self._port,
+                indices=[self._flow_xindex, self._impairment_type_xindex],
+                shape=shape,
+                scale=scale
+            )
+        )
+
+
+@register_command
+@dataclass
+class PED_CUST:
+    """
+    Associate a custom distribution to a flow and impairment type.
+
+    .. note::
+
+        Before associating a custom distribution, the below validation checks are applied.
+
+        In case of ``_impairment_type_xindex != DELAY``,
+        (1) Custom values should be less than or equal to max allowed (4194288).
+        (2) Custom distribution bust contain 512 values.
+
+        In case of ``_impairment_type_xindex = DELAY``,
+        (1) Custom values should be less than or equal to the maximum latency.
+        (2) Custom values should be greater than or equal to minimum latency.
+        (3) Custom distribution should contain 1024 values.
+
+    """
+
+    code: typing.ClassVar[int] = 1631
+    pushed: typing.ClassVar[bool] = False
+
+    _connection: 'interfaces.IConnection'
+    _module: int
+    _port: int
+    _flow_xindex: int
+    _impairment_type_xindex: int
+
+    class GetDataAttr(ResponseBodyStruct):
+        cust_id: int = field(XmpInt())
+        """integer, custom distribution identifier."""
+
+    class SetDataAttr(RequestBodyStruct):
+        cust_id: int = field(XmpInt())
+        """integer, custom distribution identifier."""
+
+    def get(self) -> Token[GetDataAttr]:
+        """Get the custom distribution identifier that is associated to a flow and impairment type.
+
+        :return: custom distribution identifier
+        :rtype: PED_CUST.GetDataAttr
+        """
+
+        return Token(self._connection, build_get_request(self, module=self._module, port=self._port, indices=[self._flow_xindex, self._impairment_type_xindex]))
+
+    def set(self, cust_id: int) -> Token[None]:
+        """Associate a custom distribution to a flow and impairment type.
+
+        :param cust_id: custom distribution identifier
+        :type cust_id: int
+        """
+
+        return Token(self._connection, build_set_request(self, module=self._module, port=self._port, indices=[self._flow_xindex, self._impairment_type_xindex], cust_id=cust_id))
+
+
+@register_command
+@dataclass
+class PED_CONST:
+    """
+    Configuration of Constant Delay distribution (DELAY only). Unit is ns (must be
+    multiples of 100ns). Default value: Minimum supported per speed and FEC mode.
+
+    .. note::
+
+        If the latency is less than minimum latency, value is set to minimum latency. If the latency is greater than maximum latency, value is set to maximum latency.
+
+    """
+
+    code: typing.ClassVar[int] = 1640
+    pushed: typing.ClassVar[bool] = False
+
+    _connection: 'interfaces.IConnection'
+    _module: int
+    _port: int
+    _flow_xindex: int
+    _impairment_type_xindex: int
+
+    class GetDataAttr(ResponseBodyStruct):
+        delay: int = field(XmpLong())
+        """long, specifies the constant delay/latency time. Unit is nanosecond (must be multiples of 100 ns). Default value: Minimum supported per speed and FEC mode."""
+
+    class SetDataAttr(RequestBodyStruct):
+        delay: int = field(XmpLong())
+        """long, specifies the constant delay/latency time. Unit is nanosecond (must be multiples of 100 ns). Default value: Minimum supported per speed and FEC mode."""
+
+    def get(self) -> Token[GetDataAttr]:
+        """Get the configuration of Constant Delay distribution (DELAY only).
+
+        :return: the configuration of Constant Delay distribution (DELAY only)
+        :rtype: PED_CONST.GetDataAttr
+        """
+
+        return Token(self._connection, build_get_request(self, module=self._module, port=self._port, indices=[self._flow_xindex, self._impairment_type_xindex]))
+
+    def set(self, delay: int) -> Token[None]:
+        """Set the configuration of Constant Delay distribution (DELAY only).
+
+        :param delay: specifies the constant delay/latency time. Unit is nanosecond (must be multiples of 100 ns). Default value: Minimum supported per speed and FEC mode.
+        :type delay: int
+        """
+
+        return Token(self._connection, build_set_request(self, module=self._module, port=self._port, indices=[self._flow_xindex, self._impairment_type_xindex], delay=delay))
+
+
+@register_command
+@dataclass
+class PED_ACCBURST:
+    """
+    Configuration of Accumulate & Burst distribution (DELAY only).
+
+    .. note::
+
+        If the delay is less than minimum latency, value is set to minimum latency. If the delay is greater than maximum latency, value is set to maximum latency.
+
+    """
+
+    code: typing.ClassVar[int] = 1641
+    pushed: typing.ClassVar[bool] = False
+
+    _connection: 'interfaces.IConnection'
+    _module: int
+    _port: int
+    _flow_xindex: int
+    _impairment_type_xindex: int
+
+    class GetDataAttr(ResponseBodyStruct):
+        delay: int = field(XmpLong())
+        """long, specifies the burst delay time. Units = nanosecond (must multiples of 100 ns). Default value: minimum latency."""
+
+    class SetDataAttr(RequestBodyStruct):
+        delay: int = field(XmpLong())
+        """long, specifies the burst delay time. Units = nanosecond (must multiples of 100 ns). Default value: minimum latency."""
+
+    def get(self) -> Token[GetDataAttr]:
+        """Get the configuration of Accumulate & Burst distribution (DELAY only).
+
+        :return: the configuration of Accumulate & Burst distribution (DELAY only)
+        :rtype: PED_ACCBURST.GetDataAttr
+        """
+
+        return Token(self._connection, build_get_request(self, module=self._module, port=self._port, indices=[self._flow_xindex, self._impairment_type_xindex]))
+
+    def set(self, delay: int) -> Token[None]:
+        """Set the configuration of Accumulate & Burst distribution (DELAY only).
+
+        :param delay: specifies the burst delay time. Units = nanosecond (must multiples of 100 ns). Default value: minimum latency.
+        :type delay: int
+        """
+
+        return Token(self._connection, build_set_request(self, module=self._module, port=self._port, indices=[self._flow_xindex, self._impairment_type_xindex], delay=delay))
+
+
+@register_command
+@dataclass
+class PED_STEP:
+    """
+    Configuration of Step distribution (DELAY only).
+
+    .. note::
+
+        If the low/high is less than minimum latency, value is set to minimum latency. If the low/high is greater than maximum latency, value is set to maximum latency.
+
+    """
+
+    code: typing.ClassVar[int] = 1642
+    pushed: typing.ClassVar[bool] = False
+
+    _connection: 'interfaces.IConnection'
+    _module: int
+    _port: int
+    _flow_xindex: int
+    _impairment_type_xindex: int
+
+    class GetDataAttr(ResponseBodyStruct):
+        low: int = field(XmpLong())
+        """long, specifies the packet delay in the 'low' state of the step. Units = nanosecond (must be multiples of 100 ns)."""
+        high: int = field(XmpLong())
+        """long, specifies the packet delay in the 'high' state of the step. Units = nanosecond (must be multiples of 100 ns)."""
+
+    class SetDataAttr(RequestBodyStruct):
+        low: int = field(XmpLong())
+        """long, specifies the packet delay in the 'low' state of the step. Units = nanosecond (must be multiples of 100 ns)."""
+        high: int = field(XmpLong())
+        """long, specifies the packet delay in the 'high' state of the step. Units = nanosecond (must be multiples of 100 ns)."""
+
+    def get(self) -> Token[GetDataAttr]:
+        """Get the configuration of Step distribution (DELAY only).
+
+        :return: the configuration of Step distribution (DELAY only)
+        :rtype: PED_STEP.GetDataAttr
+        """
+
+        return Token(self._connection, build_get_request(self, module=self._module, port=self._port, indices=[self._flow_xindex, self._impairment_type_xindex]))
+
+    def set(self, low: int, high: int) -> Token[None]:
+        """Set the configuration of Step distribution (DELAY only).
+
+        :param low: specifies the packet delay in the 'low' state of the step. Units = nanosecond (must be multiples of 100 ns).
+        :type low: int
+        :param high: specifies the packet delay in the 'high' state of the step. Units = nanosecond (must be multiples of 100 ns).
+        :type high: int
+        """
+
+        return Token(self._connection, build_set_request(self, module=self._module, port=self._port, indices=[self._flow_xindex, self._impairment_type_xindex], low=low, high=high))
+
+
+@register_command
+@dataclass
+class PED_ENABLE:
+    """
+    Control whether this impairment distribution is enabled.
+
+    .. note::
+
+        This command is not applicable for PE_BANDPOLICER and PE_BANDSHAPER because they have a separate ``ON / OFF`` parameter.
+
+    """
+
+    code: typing.ClassVar[int] = 1644
+    pushed: typing.ClassVar[bool] = True
+
+    _connection: 'interfaces.IConnection'
+    _module: int
+    _port: int
+    _flow_xindex: int
+    _impairment_type_xindex: int
+
+    class GetDataAttr(ResponseBodyStruct):
+        action: OnOff = field(XmpByte())
+        """coded byte, specifying whether impairment is enabled."""
+
+    class SetDataAttr(RequestBodyStruct):
+        action: OnOff = field(XmpByte())
+        """coded byte, specifying whether impairment is enabled."""
+
+    def get(self) -> Token[GetDataAttr]:
+        """Get the status of this impairment distribution.
+
+        :return: the status of this impairment distribution
+        :rtype: PED_ENABLE.GetDataAttr
+        """
+
+        return Token(self._connection, build_get_request(self, module=self._module, port=self._port, indices=[self._flow_xindex, self._impairment_type_xindex]))
+
+    def set(self, action: OnOff) -> Token[None]:
+        """Set the status of this impairment distribution.
+
+        :param action: the status of this impairment distribution
+        :type action: OnOff
+        """
+
+        return Token(self._connection, build_set_request(self, module=self._module, port=self._port, indices=[self._flow_xindex, self._impairment_type_xindex], action=action))
+
+    set_off = functools.partialmethod(set, OnOff.OFF)
+    """Disable impairment distribution"""
+
+    set_on = functools.partialmethod(set, OnOff.ON)
+    """Enable impairment distribution"""