How to use the sarpy.io.phase_history.cphd1_elements.base.DEFAULT_STRICT function in sarpy

class FxParametersType(Serializable):
    """
    The FX vector parameters.
    """

    _fields = ('Fx0', 'Fx_SS', 'Fx1', 'Fx2')
    _required = _fields
    # descriptors
    Fx0 = _IntegerEnumDescriptor(
        'Fx0', (8, ), _required, strict=DEFAULT_STRICT, default_value=8,
        docstring='The size of the Fx0 field')  # type: int
    Fx_SS = _IntegerEnumDescriptor(
        'Fx_SS', (8, ), _required, strict=DEFAULT_STRICT, default_value=8,
        docstring='The size of the Fx_SS field')  # type: int
    Fx1 = _IntegerEnumDescriptor(
        'Fx1', (8, ), _required, strict=DEFAULT_STRICT, default_value=8,
        docstring='The size of the Fx1 field')  # type: int
    Fx2 = _IntegerEnumDescriptor(
        'Fx2', (8, ), _required, strict=DEFAULT_STRICT, default_value=8,
        docstring='The size of the Fx2 field')  # type: int

    def __init__(self, Fx0=8, Fx_SS=8, Fx1=8, Fx2=8, **kwargs):
        if '_xml_ns' in kwargs:
            self._xml_ns = kwargs['_xml_ns']
        if '_xml_ns_key' in kwargs:
            self._xml_ns_key = kwargs['_xml_ns_key']
        self.Fx0 = Fx0
        self.Fx1 = Fx1
        self.Fx2 = Fx2
        self.Fx_SS = Fx_SS
        super(FxParametersType, self).__init__(**kwargs)

class LSType(Serializable, Arrayable):
    """
    Represents line and sample.
    """

    _fields = ('Line', 'Sample')
    _required = _fields
    _numeric_format = {'Line': '0.16G', 'Sample': '0.16G'}
    # Descriptor
    Line = _FloatDescriptor(
        'Line', _required, strict=DEFAULT_STRICT,
        docstring='The Line.')  # type: float
    Sample = _FloatDescriptor(
        'Sample', _required, strict=DEFAULT_STRICT,
        docstring='The Sample.')  # type: float

    def __init__(self, Line=None, Sample=None, **kwargs):
        """

        Parameters
        ----------
        Line : float
        Sample : float
        kwargs
        """

        if '_xml_ns' in kwargs:
            self._xml_ns = kwargs['_xml_ns']
        if '_xml_ns_key' in kwargs:
            self._xml_ns_key = kwargs['_xml_ns_key']

__classification__ = "UNCLASSIFIED"
__author__ = "Thomas McCullough"


class CollectionIDType(CollectionInfoType):
    """
    The CollectionID type definition.
    """

    _fields = (
        'CollectorName', 'IlluminatorName', 'CoreName', 'CollectType',
        'RadarMode', 'Classification', 'ReleaseInfo', 'Parameters', 'CountryCodes')
    _required = ('CollectorName', 'CoreName', 'RadarMode', 'Classification', 'ReleaseInfo')
    # descriptors
    ReleaseInfo = _StringDescriptor(
        'ReleaseInfo', _required, strict=DEFAULT_STRICT, default_value='UNRESTRICTED',
        docstring='The product release information.')  # type: str

    def __init__(self, CollectorName=None, IlluminatorName=None, CoreName=None, CollectType=None,
                 RadarMode=None, Classification="UNCLASSIFIED", ReleaseInfo='UNRESTRICTED',
                 CountryCodes=None, Parameters=None, **kwargs):
        """

        Parameters
        ----------
        CollectorName : str
        IlluminatorName : str
        CoreName : str
        CollectType : str
        RadarMode : RadarModeType
        Classification : str
        ReleaseInfo : str

"""
    The support array base case.
    """

    _fields = ('Identifier', 'ElementFormat', 'X0', 'Y0', 'XSS', 'YSS', 'NODATA')
    _required = ('Identifier', 'ElementFormat', 'X0', 'Y0', 'XSS', 'YSS')
    _numeric_format = {'X0': '0.16G', 'Y0': '0.16G', 'XSS': '0.16G', 'YSS': '0.16G'}
    # descriptors
    Identifier = _StringDescriptor(
        'Identifier', _required, strict=DEFAULT_STRICT,
        docstring='The support array identifier.')  # type: str
    ElementFormat = _StringDescriptor(
        'ElementFormat', _required, strict=DEFAULT_STRICT,
        docstring='The data element format.')  # type: str
    X0 = _FloatDescriptor(
        'X0', _required, strict=DEFAULT_STRICT,
        docstring='')  # type: float
    Y0 = _FloatDescriptor(
        'Y0', _required, strict=DEFAULT_STRICT,
        docstring='')  # type: float
    XSS = _FloatDescriptor(
        'XSS', _required, strict=DEFAULT_STRICT, bounds=(0, None),
        docstring='')  # type: float
    YSS = _FloatDescriptor(
        'YSS', _required, strict=DEFAULT_STRICT, bounds=(0, None),
        docstring='')  # type: float

    def __init__(self, Identifier=None, ElementFormat=None, X0=None, Y0=None,
                 XSS=None, YSS=None, NODATA=None, **kwargs):
        """

        Parameters

_fields = (
        'Identifier', 'PulseLength', 'RFBandwidth', 'FreqCenter', 'LFMRate',
        'Polarization', 'Power')
    _required = (
        'Identifier', 'PulseLength', 'RFBandwidth', 'FreqCenter', 'Polarization')
    _numeric_format = {
        'PulseLength': '0.16G', 'RFBandwidth': '0.16G', 'FreqCenter': '0.16G',
        'LFMRate': '0.16G', 'Power': '0.16G'}
    # descriptors
    Identifier = _StringDescriptor(
        'Identifier', _required, strict=DEFAULT_STRICT,
        docstring='String that uniquely identifies this Transmit '
                  'Waveform.')  # type: str
    PulseLength = _FloatDescriptor(
        'PulseLength', _required, strict=DEFAULT_STRICT, bounds=(0, None),
        docstring='Length of transmitted pulse, '
                  'in seconds.')  # type: float
    RFBandwidth = _FloatDescriptor(
        'RFBandwidth', _required, strict=DEFAULT_STRICT, bounds=(0, None),
        docstring='Bandwidth of transmitted pulse, '
                  'in Hz.')  # type: float
    FreqCenter = _FloatDescriptor(
        'FreqCenter', _required, strict=DEFAULT_STRICT, bounds=(0, None),
        docstring='Center frequency of the transmitted waveform, '
                  'in Hz.')  # type: float
    LFMRate = _FloatDescriptor(
        'LFMRate', _required, strict=DEFAULT_STRICT,
        docstring='Chirp rate of transmitted pulse if LFM, '
                  'in Hz/s.')  # type: Union[None, float]
    Polarization = _StringEnumDescriptor(
        'Polarization', POLARIZATION_TYPE, _required, strict=DEFAULT_STRICT,

'CompressedSignalSize')
    _required = (
        'Identifier', 'NumVectors', 'NumSamples', 'SignalArrayByteOffset', 'PVPArrayByteOffset')
    # descriptors
    Identifier = _StringDescriptor(
        'Identifier', _required, strict=DEFAULT_STRICT,
        docstring='String that uniquely identifies the CPHD channel for which the data '
                  'applies.')  # type: str
    NumVectors = _IntegerDescriptor(
        'NumVectors', _required, strict=DEFAULT_STRICT, bounds=(1, None),
        docstring='Number of vectors in the signal array.')  # type: int
    NumSamples = _IntegerDescriptor(
        'NumSamples', _required, strict=DEFAULT_STRICT, bounds=(1, None),
        docstring='Number of samples per vector in the signal array.')  # type: int
    SignalArrayByteOffset = _IntegerDescriptor(
        'SignalArrayByteOffset', _required, strict=DEFAULT_STRICT, bounds=(0, None),
        docstring='Signal Array offset from the start of the Signal block (in bytes) to the '
                  'start of the Signal Array for the channel.')  # type: int
    PVPArrayByteOffset = _IntegerDescriptor(
        'PVPArrayByteOffset', _required, strict=DEFAULT_STRICT, bounds=(0, None),
        docstring='PVP Array offset from the start of the PVP block (in bytes) to the '
                  'start of the PVP Array for the channel.')  # type: int
    CompressedSignalSize = _IntegerDescriptor(
        'CompressedSignalSize', _required, strict=DEFAULT_STRICT, bounds=(1, None),
        docstring='Size (in bytes) of the compressed signal array byte sequence for the data channel. '
                  'Parameter included if and only if the signal arrays are stored in '
                  'compressed format.')  # type: int

    def __init__(self, Identifier=None, NumVectors=None, NumSamples=None, SignalArrayByteOffset=None,
                 PVPArrayByteOffset=None, CompressedSignalSize=None, **kwargs):
        """

'IFFilterBW', _required, strict=DEFAULT_STRICT, bounds=(0, None),
        docstring='Bandwidth of the anti-aliasing filter prior to '
                  'sampling.')  # type: float
    FreqCenter = _FloatDescriptor(
        'FreqCenter', _required, strict=DEFAULT_STRICT, bounds=(0, None),
        docstring='Center frequency of the demodulation signal, '
                  'in Hz.')  # type: float
    LFMRate = _FloatDescriptor(
        'LFMRate', _required, strict=DEFAULT_STRICT,
        docstring='Chirp rate of the demodulation signal if LFM, '
                  'in Hz/s.')  # type: Union[None, float]
    Polarization = _StringEnumDescriptor(
        'Polarization', POLARIZATION_TYPE, _required, strict=DEFAULT_STRICT,
        docstring='The receive polarization mode.')  # type: str
    PathGain = _FloatDescriptor(
        'PathGain', _required, strict=DEFAULT_STRICT,
        docstring='Receiver gain from the antenna interface to the ADC, '
                  'in dB.')  # type: Union[None, float]

    def __init__(self, Identifier=None, WindowLength=None, SampleRate=None, IFFilterBW=None,
                 FreqCenter=None, LFMRate=None, Polarization=None, PathGain=None, **kwargs):
        """

        Parameters
        ----------
        Identifier : str
        WindowLength : float
        SampleRate : float
        IFFilterBW : float
        FreqCenter : float
        LFMRate : None|float
        Polarization : str

__author__ = "Thomas McCullough"


class SRPType(Serializable):
    """
    The SRP position for the reference vector of the reference channel.
    """

    _fields = ('ECF', 'IAC')
    _required = _fields
    # descriptors
    ECF = _SerializableDescriptor(
        'ECF', XYZType, _required, strict=DEFAULT_STRICT,
        docstring='SRP position in ECF coordinates.')  # type: XYZType
    IAC = _SerializableDescriptor(
        'IAC', XYZType, _required, strict=DEFAULT_STRICT,
        docstring='SRP position in Image Area Coordinates.')  # type: XYZType

    def __init__(self, ECF=None, IAC=None, **kwargs):
        """

        Parameters
        ----------
        ECF : XYZType|numpy.ndarray|list|tuple
        IAC : XYZType|numpy.ndarray|list|tuple
        kwargs
        """

        if '_xml_ns' in kwargs:
            self._xml_ns = kwargs['_xml_ns']
        if '_xml_ns_key' in kwargs:
            self._xml_ns_key = kwargs['_xml_ns_key']

Parameters that describe the collection times for the data contained in the product.
    """

    _fields = ('CollectionStart', 'RcvCollectionStart', 'TxTime1', 'TxTime2')
    _required = ('CollectionStart', 'TxTime1', 'TxTime2')
    _numeric_format = {'TxTime1': '0.16G', 'TxTime2': '0.16G'}
    # descriptors
    CollectionStart = _DateTimeDescriptor(
        'CollectionStart', _required, strict=DEFAULT_STRICT, numpy_datetime_units='us',
        docstring='Collection Start date and time (UTC). Time reference used for times '
                  'measured from collection start (i.e. slow time t = 0). For bistatic '
                  'collections, the time is the transmit platform collection '
                  'start time. The default display precision is microseconds, but this '
                  'does not that accuracy in value.')  # type: numpy.datetime64
    RcvCollectionStart = _DateTimeDescriptor(
        'RcvCollectionStart', _required, strict=DEFAULT_STRICT, numpy_datetime_units='us',
        docstring='Receive only platform collection date and start time.')  # type: numpy.datetime64
    TxTime1 = _FloatDescriptor(
        'TxTime1', _required, strict=DEFAULT_STRICT, bounds=(0, None),
        docstring='Earliest TxTime value for any signal vector in the product. '
                  'Time relative to Collection Start in seconds.')  # type: float
    TxTime2 = _FloatDescriptor(
        'TxTime2', _required, strict=DEFAULT_STRICT, bounds=(0, None),
        docstring='Latest TxTime value for any signal vector in the product. '
                  'Time relative to Collection Start in seconds.')  # type: float

    def __init__(self, CollectionStart=None, RcvCollectionStart=None, TxTime1=None, TxTime2=None, **kwargs):
        """

        Parameters
        ----------
        CollectionStart : numpy.datetime64|datetime|date|str

class HPBWType(Serializable):
    """
    Half power beamwidth parameters.
    """

    _fields = ('DCX', 'DCY')
    _required = _fields
    _numeric_format = {'DCX': '0.16G', 'DCY': '0.16G'}
    # descriptors
    DCX = _FloatDescriptor(
        'DCX', _required, strict=DEFAULT_STRICT,
        docstring='Half power beamwidth in the X-axis direction cosine '
                  '(DCX).')  # type: float
    DCY = _FloatDescriptor(
        'DCY', _required, strict=DEFAULT_STRICT,
        docstring='Half power beamwidth in the Y -axis direction cosine '
                  '(DCY).')  # type: float

    def __init__(self, DCX=None, DCY=None, **kwargs):
        """

        Parameters
        ----------
        DCX : float
        DCY : float
        kwargs
        """

        if '_xml_ns' in kwargs:
            self._xml_ns = kwargs['_xml_ns']
        if '_xml_ns_key' in kwargs: