How to use the ophyd.device.DynamicDeviceComponent function in ophyd

max_size = DDC(ad_group(EpicsSignalRO,
                            (('max_size_x', 'MaxSizeX_RBV'),
                             ('max_size_y', 'MaxSizeY_RBV'))),
                   doc='Maximum sensor size in the XY directions')

    min_x = C(SignalWithRBV, 'MinX')
    min_y = C(SignalWithRBV, 'MinY')
    model = C(EpicsSignalRO, 'Model_RBV')

    num_exposures = C(SignalWithRBV, 'NumExposures')
    num_exposures_counter = C(EpicsSignalRO, 'NumExposuresCounter_RBV')
    num_images = C(SignalWithRBV, 'NumImages')
    num_images_counter = C(EpicsSignalRO, 'NumImagesCounter_RBV')

    read_status = C(EpicsSignal, 'ReadStatus')
    reverse = DDC(ad_group(SignalWithRBV,
                           (('reverse_x', 'ReverseX'),
                            ('reverse_y', 'ReverseY'))
                           ))

    shutter_close_delay = C(SignalWithRBV, 'ShutterCloseDelay')
    shutter_close_epics = C(EpicsSignal, 'ShutterCloseEPICS')
    shutter_control = C(SignalWithRBV, 'ShutterControl')
    shutter_control_epics = C(EpicsSignal, 'ShutterControlEPICS')
    shutter_fanout = C(EpicsSignal, 'ShutterFanout')
    shutter_mode = C(SignalWithRBV, 'ShutterMode')
    shutter_open_delay = C(SignalWithRBV, 'ShutterOpenDelay')
    shutter_open_epics = C(EpicsSignal, 'ShutterOpenEPICS')
    shutter_status_epics = C(EpicsSignalRO, 'ShutterStatusEPICS_RBV')
    shutter_status = C(EpicsSignalRO, 'ShutterStatus_RBV')

    size = DDC(ad_group(SignalWithRBV,

('fc4', 'FC4'))),
             doc='Filter coefficients',
             default_read_attrs=('fc1', 'fc2', 'fc3', 'fc4'))

    foffset = C(SignalWithRBV, 'FOffset')
    fscale = C(SignalWithRBV, 'FScale')
    filter_callbacks = C(SignalWithRBV, 'FilterCallbacks', string=True)
    filter_type = C(EpicsSignal, 'FilterType', string=True)
    filter_type_seq = C(EpicsSignal, 'FilterTypeSeq')
    high_clip = C(SignalWithRBV, 'HighClip')
    low_clip = C(SignalWithRBV, 'LowClip')
    num_filter = C(SignalWithRBV, 'NumFilter')
    num_filter_recip = C(EpicsSignal, 'NumFilterRecip')
    num_filtered = C(EpicsSignalRO, 'NumFiltered_RBV')

    oc = DDC(ad_group(SignalWithRBV,
                      (('oc1', 'OC1'),
                       ('oc2', 'OC2'),
                       ('oc3', 'OC3'),
                       ('oc4', 'OC4'))),
             doc='Output coefficients',
             default_read_attrs=('oc1', 'oc2', 'oc3', 'oc4'))

    o_offset = C(SignalWithRBV, 'OOffset')
    o_scale = C(SignalWithRBV, 'OScale')
    offset = C(SignalWithRBV, 'Offset')

    rc = DDC(ad_group(SignalWithRBV,
                      (('rc1', 'RC1'),
                       ('rc2', 'RC2'))),
             doc='Filter coefficients',
             default_read_attrs=('rc1', 'rc2'))

(('x', 'MaxX_RBV'),
                           ('y', 'MaxY_RBV'))),
                 doc='Maximum in XY',
                 default_read_attrs=('x', 'y'))

    mean_value = C(EpicsSignalRO, 'MeanValue_RBV')
    min_value = C(EpicsSignalRO, 'MinValue_RBV')

    min_xy = DDC(ad_group(EpicsSignalRO,
                          (('x', 'MinX_RBV'),
                           ('y', 'MinY_RBV'))),
                 doc='Minimum in XY',
                 default_read_attrs=('x', 'y'))

    net = C(EpicsSignalRO, 'Net_RBV')
    profile_average = DDC(ad_group(EpicsSignalRO,
                                   (('x', 'ProfileAverageX_RBV'),
                                    ('y', 'ProfileAverageY_RBV'))),
                          doc='Profile average in XY',
                          default_read_attrs=('x', 'y'))

    profile_centroid = DDC(ad_group(EpicsSignalRO,
                                    (('x', 'ProfileCentroidX_RBV'),
                                     ('y', 'ProfileCentroidY_RBV'))),
                           doc='Profile centroid in XY',
                           default_read_attrs=('x', 'y'))

    profile_cursor = DDC(ad_group(EpicsSignalRO,
                                  (('x', 'ProfileCursorX_RBV'),
                                   ('y', 'ProfileCursorY_RBV'))),
                         doc='Profile cursor in XY',
                         default_read_attrs=('x', 'y'))

(('peak_num_x', 'PeakNumX'),
                             ('peak_num_y', 'PeakNumY'))),
                   doc='Peak number in XY')

    peak_start = DDC(ad_group(SignalWithRBV,
                              (('peak_start_x', 'PeakStartX'),
                               ('peak_start_y', 'PeakStartY'))),
                     doc='Peak start in XY')

    peak_step = DDC(ad_group(SignalWithRBV,
                             (('peak_step_x', 'PeakStepX'),
                              ('peak_step_y', 'PeakStepY'))),
                    doc='Peak step in XY')

    peak_variation = ADCpt(SignalWithRBV, 'PeakVariation')
    peak_width = DDC(ad_group(SignalWithRBV,
                              (('peak_width_x', 'PeakWidthX'),
                               ('peak_width_y', 'PeakWidthY'))),
                     doc='Peak width in XY')

    reset = ADCpt(SignalWithRBV, 'Reset')
    sim_mode = ADCpt(SignalWithRBV, 'SimMode')


class AdscDetectorCam(CamBase):
    _html_docs = ['adscDoc.html']
    adsc_2theta = ADCpt(SignalWithRBV, 'ADSC2Theta')
    adsc_adc = ADCpt(SignalWithRBV, 'ADSCAdc')
    adsc_axis = ADCpt(SignalWithRBV, 'ADSCAxis')
    adsc_beam_x = ADCpt(SignalWithRBV, 'ADSCBeamX')
    adsc_beam_y = ADCpt(SignalWithRBV, 'ADSCBeamY')
    adsc_dezingr = ADCpt(SignalWithRBV, 'ADSCDezingr')

bgd_width = C(SignalWithRBV, 'BgdWidth')
    centroid_threshold = C(SignalWithRBV, 'CentroidThreshold')

    centroid = DDC(ad_group(EpicsSignalRO,
                            (('x', 'CentroidX_RBV'),
                             ('y', 'CentroidY_RBV'))),
                   doc='The centroid XY',
                   default_read_attrs=('x', 'y'))

    compute_centroid = C(SignalWithRBV, 'ComputeCentroid', string=True)
    compute_histogram = C(SignalWithRBV, 'ComputeHistogram', string=True)
    compute_profiles = C(SignalWithRBV, 'ComputeProfiles', string=True)
    compute_statistics = C(SignalWithRBV, 'ComputeStatistics', string=True)

    cursor = DDC(ad_group(SignalWithRBV,
                          (('x', 'CursorX'),
                           ('y', 'CursorY'))),
                 doc='The cursor XY',
                 default_read_attrs=('x', 'y'))

    hist_entropy = C(EpicsSignalRO, 'HistEntropy_RBV')
    hist_max = C(SignalWithRBV, 'HistMax')
    hist_min = C(SignalWithRBV, 'HistMin')
    hist_size = C(SignalWithRBV, 'HistSize')
    histogram = C(EpicsSignalRO, 'Histogram_RBV')

    max_size = DDC(ad_group(EpicsSignal,
                            (('x', 'MaxSizeX'),
                             ('y', 'MaxSizeY'))),
                   doc='The maximum size in XY',
                   default_read_attrs=('x', 'y'))

default_read_attrs=('x', 'y'))

    ts_control = C(EpicsSignal, 'TSControl', string=True)
    ts_current_point = C(EpicsSignal, 'TSCurrentPoint')
    ts_max_value = C(EpicsSignal, 'TSMaxValue')

    ts_max = DDC(ad_group(EpicsSignal,
                          (('x', 'TSMaxX'),
                           ('y', 'TSMaxY'))),
                 doc='Time series maximum in XY',
                 default_read_attrs=('x', 'y'))

    ts_mean_value = C(EpicsSignal, 'TSMeanValue')
    ts_min_value = C(EpicsSignal, 'TSMinValue')

    ts_min = DDC(ad_group(EpicsSignal,
                          (('x', 'TSMinX'),
                           ('y', 'TSMinY'))),
                 doc='Time series minimum in XY',
                 default_read_attrs=('x', 'y'))

    ts_net = C(EpicsSignal, 'TSNet')
    ts_num_points = C(EpicsSignal, 'TSNumPoints')
    ts_read = C(EpicsSignal, 'TSRead')
    ts_sigma = C(EpicsSignal, 'TSSigma')
    ts_sigma_x = C(EpicsSignal, 'TSSigmaX')
    ts_sigma_xy = C(EpicsSignal, 'TSSigmaXY')
    ts_sigma_y = C(EpicsSignal, 'TSSigmaY')
    ts_total = C(EpicsSignal, 'TSTotal')
    total = C(EpicsSignalRO, 'Total_RBV')

threshold_2_actual = C(EpicsSignalRO, 'ThresholdActual2_RBV')
    threshold_3_actual = C(EpicsSignalRO, 'ThresholdActual3_RBV')
    threshold_4_actual = C(EpicsSignalRO, 'ThresholdActual4_RBV')
    thresholds_actual = DDC(ad_group(EpicsSignalRO,
                                     (('threshold_1', 'ThresholdActual1_RBV'),
                                      ('threshold_2', 'ThresholdActual2_RBV'),
                                      ('threshold_3', 'ThresholdActual3_RBV'),
                                      ('threshold_4', 'ThresholdActual4_RBV'),
                                      )),
                            doc='Actual thresholds')

    threshold_1 = C(SignalWithRBV, 'Threshold1')
    threshold_2 = C(SignalWithRBV, 'Threshold2')
    threshold_3 = C(SignalWithRBV, 'Threshold3')
    threshold_4 = C(SignalWithRBV, 'Threshold4')
    thresholds = DDC(ad_group(SignalWithRBV,
                              (('threshold_1', 'Threshold1'),
                               ('threshold_2', 'Threshold2'),
                               ('threshold_3', 'Threshold3'),
                               ('threshold_4', 'Threshold4'),
                               )),
                     doc='Thresholds')

    udp_buffers_free = C(EpicsSignalRO, 'UDPBuffersFree_RBV')
    udp_buffers_max = C(EpicsSignalRO, 'UDPBuffersMax_RBV')
    udp_buffers_read = C(EpicsSignalRO, 'UDPBuffersRead_RBV')
    udp_speed = C(EpicsSignalRO, 'UDPSpeed_RBV')


class PointGreyDetectorCam(CamBase):
    _html_docs = ['PointGreyDoc.html']

overlay_8 = C(Overlay, '8:')


class ROIPlugin(PluginBase):
 
    _default_suffix = 'ROI1:'
    _suffix_re = 'ROI\d:'
    _html_docs = ['NDPluginROI.html']
    _plugin_type = 'NDPluginROI'
    _default_configuration_attrs = (PluginBase._default_configuration_attrs + (
        'roi_enable', 'name_', 'bin_', 'data_type_out', 'enable_scale')
    )
    _default_read_attrs = ('enable', 'min_xyz.min_x', 'size.x',
                           'min_xyz.min_y', 'size.y', 'min_xyz.min_z',
                           'size.z')
    array_size = DDC(ad_group(EpicsSignalRO,
                              (('x', 'ArraySizeX_RBV'),
                               ('y', 'ArraySizeY_RBV'),
                               ('z', 'ArraySizeZ_RBV'))),
                     doc='Size of the ROI data in XYZ',
                     default_read_attrs=('x', 'y', 'z'))

    auto_size = DDC(ad_group(SignalWithRBV,
                             (('x', 'AutoSizeX'),
                              ('y', 'AutoSizeY'),
                              ('z', 'AutoSizeZ'))),
                    doc=('Automatically set SizeXYZ to the input array size '
                         'minus MinXYZ'),
                    default_read_attrs=('x', 'y', 'z'))

    bin_ = DDC(ad_group(SignalWithRBV,
                        (('x', 'BinX'),

'zlevel')
    )

    boundary_align = C(SignalWithRBV, 'BoundaryAlign')
    boundary_threshold = C(SignalWithRBV, 'BoundaryThreshold')
    compression = C(SignalWithRBV, 'Compression')
    data_bits_offset = C(SignalWithRBV, 'DataBitsOffset')

    extra_dim_name = DDC(ad_group(EpicsSignalRO,
                                  (('name_x', 'ExtraDimNameX_RBV'),
                                   ('name_y', 'ExtraDimNameY_RBV'),
                                   ('name_n', 'ExtraDimNameN_RBV'))),
                         doc='Extra dimension names (XYN)',
                         default_read_attrs=('name_x', 'name_y', 'name_n'))

    extra_dim_size = DDC(ad_group(SignalWithRBV,
                                  (('size_x', 'ExtraDimSizeX'),
                                   ('size_y', 'ExtraDimSizeY'),
                                   ('size_n', 'ExtraDimSizeN'))),
                         doc='Extra dimension sizes (XYN)',
                         default_read_attrs=('size_x', 'size_y', 'size_n'))


    io_speed = C(EpicsSignal, 'IOSpeed')
    num_col_chunks = C(SignalWithRBV, 'NumColChunks')
    num_data_bits = C(SignalWithRBV, 'NumDataBits')
    num_extra_dims = C(SignalWithRBV, 'NumExtraDims')
    num_frames_chunks = C(SignalWithRBV, 'NumFramesChunks')
    num_frames_flush = C(SignalWithRBV, 'NumFramesFlush')
    num_row_chunks = C(SignalWithRBV, 'NumRowChunks')
    run_time = C(EpicsSignal, 'RunTime')
    szip_num_pixels = C(SignalWithRBV, 'SZipNumPixels')

self.s.name = self.chname.get()


def _sc_chans(attr_fix, id_range):
    defn = OrderedDict()
    for k in id_range:
        defn['{}{:02d}'.format(attr_fix, k)] = (ScalerChannel,
                                                '', {'ch_num': k,
                                                     'kind': Kind.normal})
    return defn


class ScalerCH(Device):

    # The data
    channels = DDCpt(_sc_chans('chan', range(1, 33)))

    # tigger + trigger mode
    count = Cpt(EpicsSignal, '.CNT', trigger_value=1, kind=Kind.omitted)
    count_mode = Cpt(EpicsSignal, '.CONT', string=True, kind=Kind.config)

    # delay from triggering to starting counting
    delay = Cpt(EpicsSignal, '.DLY', kind=Kind.config)
    auto_count_delay = Cpt(EpicsSignal, '.DLY1', kind=Kind.config)

    time = Cpt(EpicsSignal, '.T')
    freq = Cpt(EpicsSignal, '.FREQ', kind=Kind.config)

    preset_time = Cpt(EpicsSignal, '.TP', kind=Kind.config)
    auto_count_time = Cpt(EpicsSignal, '.TP1', kind=Kind.config)

    update_rate = Cpt(EpicsSignal, '.RATE', kind=Kind.omitted)