How to use the sarpy.io.complex.sicd_elements.base._SerializableListDescriptor function in sarpy

CollectionDateTime = _DateTimeDescriptor(
        'CollectionDateTime', _required, strict=DEFAULT_STRICT,
        docstring='Collection date and time defined in Coordinated Universal Time (UTC). The seconds '
                  'should be followed by a Z to indicate UTC.')  # type: numpy.datetime64
    CollectionDuration = _FloatDescriptor(
        'CollectionDuration', _required, strict=DEFAULT_STRICT,
        docstring='The duration of the collection (units = seconds).')  # type: float
    Resolution = _SerializableDescriptor(
        'Resolution', RangeAzimuthType, _required, strict=DEFAULT_STRICT,
        docstring='Uniformly-weighted resolution (range and azimuth) processed in '
                  'the slant plane.')  # type: Union[None, RangeAzimuthType]
    InputROI = _SerializableDescriptor(
        'InputROI', InputROIType, _required, strict=DEFAULT_STRICT,
        docstring='ROI representing portion of input data used to make '
                  'this product.')  # type: Union[None, InputROIType]
    Polarizations = _SerializableListDescriptor(
        'Polarizations', TxRcvPolarizationType, _collections_tags, _required, strict=DEFAULT_STRICT,
        docstring='Transmit and receive polarization(s).')  # type: Union[None, List[TxRcvPolarizationType]]

    def __init__(self, SensorName=None, RadarMode=None, CollectionDateTime=None, LocalDateTime=None,
                 CollectionDuration=None, Resolution=None, Polarizations=None, **kwargs):
        """

        Parameters
        ----------
        SensorName : str
        RadarMode : RadarModeType
        CollectionDateTime : numpy.datetime64|datetime.datetime|datetime.date|str
        LocalDateTime : None|str|datetime.datetime
        CollectionDuration : float
        Resolution : None|RangeAzimuthType|numpy.ndarray|list|tuple
        Polarizations : None|List[TxTcvPolarizationType]

CollectionDateTime = _DateTimeDescriptor(
        'CollectionDateTime', _required, strict=DEFAULT_STRICT,
        docstring='Collection date and time defined in Coordinated Universal Time (UTC). The seconds '
                  'should be followed by a Z to indicate UTC.')  # type: numpy.datetime64
    CollectionDuration = _FloatDescriptor(
        'CollectionDuration', _required, strict=DEFAULT_STRICT,
        docstring='The duration of the collection (units = seconds).')  # type: float
    Resolution = _SerializableDescriptor(
        'Resolution', RangeAzimuthType, _required, strict=DEFAULT_STRICT,
        docstring='Uniformly-weighted resolution (range and azimuth) processed in '
                  'the slant plane.')  # type: Union[None, RangeAzimuthType]
    InputROI = _SerializableDescriptor(
        'InputROI', InputROIType, _required, strict=DEFAULT_STRICT,
        docstring='ROI representing portion of input data used to make '
                  'this product.')  # type: Union[None, InputROIType]
    Polarizations = _SerializableListDescriptor(
        'Polarizations', TxRcvPolarizationType, _collections_tags, _required, strict=DEFAULT_STRICT,
        docstring='Transmit and receive polarization(s).')  # type: Union[None, List[TxRcvPolarizationType]]

    def __init__(self, SensorName=None, RadarMode=None, CollectionDateTime=None, LocalDateTime=None,
                 CollectionDuration=None, Resolution=None, Polarizations=None, **kwargs):
        """

        Parameters
        ----------
        SensorName : str
        RadarMode : RadarModeType
        CollectionDateTime : numpy.datetime64|datetime.datetime|datetime.date|str
        LocalDateTime : None|str|datetime.datetime
        CollectionDuration : float
        Resolution : None|RangeAzimuthType|numpy.ndarray|list|tuple
        Polarizations : None|List[TxTcvPolarizationType]

if self.MatchCollections is None:
            return 0
        else:
            return len(self.MatchCollections)


class MatchInfoType(Serializable):
    """
    The match information container. This contains data for multiple collection taskings.
    """

    _fields = ('NumMatchTypes', 'MatchTypes')
    _required = ('MatchTypes', )
    _collections_tags = {'MatchTypes': {'array': False, 'child_tag': 'MatchType'}}
    # descriptors
    MatchTypes = _SerializableListDescriptor(
        'MatchTypes', MatchType, _collections_tags, _required, strict=DEFAULT_STRICT,
        docstring='The match types list.')  # type: List[MatchType]

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

        Parameters
        ----------
        MatchTypes : List[MatchType]
        kwargs : dict
        """

        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']

class ExploitationFeaturesType(Serializable):
    """
    Computed metadata regarding the collect.
    """
    _fields = ('Collections', 'Products')
    _required = ('Collections', 'Products')
    _collections_tags = {
        'Collections': {'array': False, 'child_tag': 'Collection'},
        'Products': {'array': False, 'child_tag': 'Product'}}
    # Descriptor
    Collections = _SerializableListDescriptor(
        'Collections', CollectionType, _collections_tags, _required, strict=DEFAULT_STRICT,
        docstring='')  # type: List[CollectionType]
    Products = _SerializableListDescriptor(
        'Products', ExploitationFeaturesProductType, _collections_tags, _required, strict=DEFAULT_STRICT,
        docstring='')  # type: List[ExploitationFeaturesProductType]

    def __init__(self, Collections=None, Products=None, **kwargs):
        """

        Parameters
        ----------
        Collections : List[CollectionType]
        Products : List[ExploitationFeaturesProductType]
        kwargs
        """

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

Parameters that describe binary data components contained in the product.
    """

    _fields = ('SampleType', 'NumCPHDChannels', 'NumBytesVBP', 'ArraySize')
    _required = ('SampleType', 'NumBytesVBP', 'ArraySize')
    _collections_tags = {'ArraySize': {'array': False, 'child_tag': 'ArraySize'}}
    # descriptors
    SampleType = _StringEnumDescriptor(
        'SampleType', ("RE32F_IM32F", "RE16I_IM16I", "RE08I_IM08I"), _required, strict=True,
        docstring="Indicates the PHD sample format of the PHD array(s). All arrays "
                  "have the sample type. Real and imaginary components stored in adjacent "
                  "bytes, real component stored first.")  # type: str
    NumBytesVBP = _IntegerDescriptor(
        'NumBytesVBP', _required, strict=DEFAULT_STRICT, bounds=(1, None),
        docstring='Number of bytes per set of Vector Based Parameters.')  # type: int
    ArraySize = _SerializableListDescriptor(
        'ArraySize', ArraySizeType, _collections_tags, _required, strict=DEFAULT_STRICT,
        docstring='CPHD array size parameters.')  # type: List[ArraySizeType]

    def __init__(self, SampleType=None, NumBytesVBP=None, ArraySize=None, **kwargs):
        """

        Parameters
        ----------
        SampleType : str
        NumBytesVBP : int
        ArraySize : List[ArraySizeType]
        kwargs
        """

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

self.Resolution = Resolution
        self.North = North
        self.Extensions = Extensions
        super(ExploitationFeaturesProductType, self).__init__(**kwargs)


class ExploitationFeaturesType(Serializable):
    """
    Computed metadata regarding the collect.
    """
    _fields = ('Collections', 'Product')
    _required = ('Collections', 'Product')
    _collections_tags = {
        'Collections': {'array': False, 'child_tag': 'Collection'}}
    # Descriptor
    Collections = _SerializableListDescriptor(
        'Collections', CollectionType, _collections_tags, _required, strict=DEFAULT_STRICT,
        docstring='')  # type: List[CollectionType]
    Product = _SerializableDescriptor(
        'Product', ExploitationFeaturesProductType, _required, strict=DEFAULT_STRICT,
        docstring='')  # type: ExploitationFeaturesProductType

    def __init__(self, Collections=None, Product=None, **kwargs):
        """

        Parameters
        ----------
        Collections : List[CollectionType]
        Product : ExploitationFeaturesProductType
        kwargs
        """

class SupportArrayType(Serializable):
    """
    Parameters that describe the binary support array(s) content and
    grid coordinates.
    """

    _fields = ('IAZArray', 'AntGainPhase', 'AddedSupportArray')
    _required = ()
    _collections_tags = {
        'IAZArray': {'array': False, 'child_tag': 'IAZArray'},
        'AntGainPhase': {'array': False, 'child_tag': 'AntGainPhase'},
        'AddedSupportArray': {'array': False, 'child_tag': 'AddedSupportArray'}}
    # descriptors
    IAZArray = _SerializableListDescriptor(
        'IAZArray', IAZArrayType, _collections_tags, _required, strict=DEFAULT_STRICT,
        docstring='Arrays of scene surface heights expressed in image coordinate IAZ '
                  'values (meters). Grid coordinates are image area coordinates '
                  '(IAX, IAY).')  # type: Union[None, List[IAZArrayType]]
    AntGainPhase = _SerializableListDescriptor(
        'AntGainPhase', AntGainPhaseType, _collections_tags, _required, strict=DEFAULT_STRICT,
        docstring='Antenna arrays with values are antenna gain and phase expressed in dB '
                  'and cycles. Array coordinates are direction cosines with respect to '
                  'the ACF (DCX, DCY).')  # type: Union[None, List[AntGainPhaseType]]
    AddedSupportArray = _SerializableListDescriptor(
        'AddedSupportArray', AddedSupportArrayType, _collections_tags, _required, strict=DEFAULT_STRICT,
        docstring='Additional arrays (two-dimensional), where the content and format and units of each '
                  'element are user defined.')  # type: Union[None, List[AddedSupportArrayType]]

    def __init__(self, IAZArray=None, AntGainPhase=None, AddedSupportArray=None, **kwargs):
        """

_required = ('Resolution', 'Ellipticity', 'Polarizations')
    _collections_tags = {
        'Polarizations': {'array': False, 'child_tag': 'Polarization'},
        'Extensions': {'array': False, 'child_tag': 'Extension'}}
    _numeric_format = {'Ellipticity': '0.16G', 'North': '0.16G'}
    # Descriptor
    Resolution = _SerializableDescriptor(
        'Resolution', RowColDoubleType, _required, strict=DEFAULT_STRICT,
        docstring='Uniformly-weighted resolution projected into the Earth Tangent '
                  'Plane (ETP).')  # type: RowColDoubleType
    Ellipticity = _FloatDescriptor(
        'Ellipticity', _required, strict=DEFAULT_STRICT,
        docstring="Ellipticity of the 2D-IPR at the ORP, measured in the *Earth Geodetic "
                  "Tangent Plane (EGTP)*. Ellipticity is the ratio of the IPR ellipse's "
                  "major axis to minor axis.")  # type: float
    Polarizations = _SerializableListDescriptor(
        'Polarizations', ProcTxRcvPolarizationType, _collections_tags, _required, strict=DEFAULT_STRICT,
        docstring='Describes the processed transmit and receive polarizations for the '
                  'product.')  # type: List[ProcTxRcvPolarizationType]
    North = _FloatModularDescriptor(
        'North', 180.0, _required, strict=DEFAULT_STRICT,
        docstring='Counter-clockwise angle from increasing row direction to north at the center '
                  'of the image.')  # type: float
    Extensions = _ParametersDescriptor(
        'Extensions', _collections_tags, _required, strict=DEFAULT_STRICT,
        docstring='Exploitation feature extension related to geometry for a '
                  'single input image.')  # type: ParametersCollection

    def __init__(self, Resolution=None, Ellipticity=None, Polarizations=None,
                 North=None, Extensions=None, **kwargs):
        """

# Descriptors
    PixelType = _StringEnumDescriptor(
        'PixelType', ('MONO8I', 'MONO8LU', 'MONO16I', 'RGBL8U', 'RGB24I'), _required, strict=DEFAULT_STRICT,
        docstring='Enumeration of the pixel type. Definition in '
                  'Design and Exploitation document.')  # type: str
    NumBands = _IntegerDescriptor(
        'NumBands', _required, strict=DEFAULT_STRICT,
        docstring='Number of bands contained in the image. Populate with the number of bands '
                  'present after remapping. For example an 8-bit RGB image (RGBLU), this will '
                  'be 3.')  # type: int
    DefaultBandDisplay = _IntegerDescriptor(
        'DefaultBandDisplay', _required, strict=DEFAULT_STRICT,
        docstring='Indicates which band to display by default. '
                  'Valid range = 1 to NumBands.')  # type: int
    NonInteractiveProcessing = _SerializableListDescriptor(
        'NonInteractiveProcessing', NonInteractiveProcessingType, _collections_tags, _required, strict=DEFAULT_STRICT,
        docstring='Non-interactive processing details.')  # type: List[NonInteractiveProcessingType]
    InteractiveProcessing = _SerializableListDescriptor(
        'InteractiveProcessing', InteractiveProcessingType, _collections_tags, _required, strict=DEFAULT_STRICT,
        docstring='Interactive processing details.')  # type: List[InteractiveProcessingType]
    DisplayExtensions = _ParametersDescriptor(
        'DisplayExtensions', _collections_tags, _required, strict=DEFAULT_STRICT,
        docstring='Optional extensible parameters used to support profile-specific needs related to '
                  'product display. Predefined filter types.')  # type: ParametersCollection

    def __init__(self, PixelType=None, NumBands=1, DefaultBandDisplay=None,
                 NonInteractiveProcessing=None, InteractiveProcessing=None, DisplayExtensions=None, **kwargs):
        """

        Parameters
        ----------

_required = ('AntCoordFrame', 'AntPhaseCenter', 'AntPattern')
    _collections_tags = {
        'AntCoordFrame': {'array': False, 'child_tag': 'AntCoordFrame'},
        'AntPhaseCenter': {'array': False, 'child_tag': 'AntPhaseCenter'},
        'AntPattern': {'array': False, 'child_tag': 'AntPattern'}}
    # descriptors
    AntCoordFrame = _SerializableListDescriptor(
        'AntCoordFrame', AntCoordFrameType, _collections_tags, _required, strict=DEFAULT_STRICT,
        docstring='Unit vectors that describe the orientation of an Antenna Coordinate Frame (ACF) '
                  'as function of time. Parameter set repeated for '
                  'each ACF.')  # type: List[AntCoordFrameType]
    AntPhaseCenter = _SerializableListDescriptor(
        'AntPhaseCenter', AntPhaseCenterType, _collections_tags, _required, strict=DEFAULT_STRICT,
        docstring='Parameters that describe each Antenna Phase Center (APC). Parameter '
                  'set repeated for each APC.')  # type: List[AntPhaseCenterType]
    AntPattern = _SerializableListDescriptor(
        'AntPattern', AntPatternType, _collections_tags, _required, strict=DEFAULT_STRICT,
        docstring='Parameter set that defines each Antenna Pattern as function time. Parameters '
                  'set repeated for each Antenna Pattern.')  # type: List[AntPatternType]

    def __init__(self, AntCoordFrame=None, AntPhaseCenter=None, AntPattern=None, **kwargs):
        """

        Parameters
        ----------
        AntCoordFrame : List[AntCoordFrameType]
        AntPhaseCenter : List[AntPhaseCenterType]
        AntPattern : List[AntPatternType]
        kwargs
        """

        if '_xml_ns' in kwargs: