# serializer version: 1
# name: test_diagnostics
  dict({
    'config_entry': dict({
      'data': dict({
        'ip_address': '127.0.0.1',
        'port': 80,
      }),
      'disabled_by': None,
      'discovery_keys': dict({
      }),
      'domain': 'screenlogic',
      'entry_id': 'screenlogictest',
      'minor_version': 1,
      'options': dict({
        'scan_interval': 30,
      }),
      'pref_disable_new_entities': False,
      'pref_disable_polling': False,
      'source': 'user',
      'subentries': list([
      ]),
      'title': 'Pentair: DD-EE-FF',
      'unique_id': 'aa:bb:cc:dd:ee:ff',
      'version': 1,
    }),
    'data': dict({
      'adapter': dict({
        'firmware': dict({
          'major': 5.2,
          'minor': 736.0,
          'name': 'Protocol Adapter Firmware',
          'value': 'POOL: 5.2 Build 736.0 Rel',
        }),
      }),
      'body': dict({
        '0': dict({
          'body_type': 0,
          'cool_setpoint': dict({
            'device_type': 'temperature',
            'name': 'Pool Cool Set Point',
            'unit': '°F',
            'value': 100,
          }),
          'heat_mode': dict({
            'device_type': 'enum',
            'enum_options': list([
              'Off',
              'Solar',
              'Solar Preferred',
              'Heater',
              "Don't Change",
            ]),
            'name': 'Pool Heat Mode',
            'value': 0,
          }),
          'heat_setpoint': dict({
            'device_type': 'temperature',
            'name': 'Pool Heat Set Point',
            'unit': '°F',
            'value': 83,
          }),
          'heat_state': dict({
            'device_type': 'enum',
            'enum_options': list([
              'Off',
              'Solar',
              'Heater',
              'Both',
            ]),
            'name': 'Pool Heat',
            'value': 0,
          }),
          'last_temperature': dict({
            'device_type': 'temperature',
            'name': 'Last Pool Temperature',
            'state_type': 'measurement',
            'unit': '°F',
            'value': 81,
          }),
          'max_setpoint': 104,
          'min_setpoint': 40,
          'name': 'Pool',
        }),
        '1': dict({
          'body_type': 1,
          'cool_setpoint': dict({
            'device_type': 'temperature',
            'name': 'Spa Cool Set Point',
            'unit': '°F',
            'value': 69,
          }),
          'heat_mode': dict({
            'device_type': 'enum',
            'enum_options': list([
              'Off',
              'Solar',
              'Solar Preferred',
              'Heater',
              "Don't Change",
            ]),
            'name': 'Spa Heat Mode',
            'value': 0,
          }),
          'heat_setpoint': dict({
            'device_type': 'temperature',
            'name': 'Spa Heat Set Point',
            'unit': '°F',
            'value': 94,
          }),
          'heat_state': dict({
            'device_type': 'enum',
            'enum_options': list([
              'Off',
              'Solar',
              'Heater',
              'Both',
            ]),
            'name': 'Spa Heat',
            'value': 0,
          }),
          'last_temperature': dict({
            'device_type': 'temperature',
            'name': 'Last Spa Temperature',
            'state_type': 'measurement',
            'unit': '°F',
            'value': 84,
          }),
          'max_setpoint': 104,
          'min_setpoint': 40,
          'name': 'Spa',
        }),
      }),
      'circuit': dict({
        '500': dict({
          'circuit_id': 500,
          'color': dict({
            'color_position': 0,
            'color_set': 0,
            'color_stagger': 0,
          }),
          'configuration': dict({
            'default_runtime': 720,
            'delay': 0,
            'flags': 1,
            'name_index': 71,
            'unknown_at_offset_62': 0,
            'unknown_at_offset_63': 0,
          }),
          'device_id': 1,
          'function': 1,
          'interface': 1,
          'name': 'Spa',
          'value': 0,
        }),
        '501': dict({
          'circuit_id': 501,
          'color': dict({
            'color_position': 0,
            'color_set': 0,
            'color_stagger': 0,
          }),
          'configuration': dict({
            'default_runtime': 720,
            'delay': 0,
            'flags': 0,
            'name_index': 85,
            'unknown_at_offset_94': 0,
            'unknown_at_offset_95': 0,
          }),
          'device_id': 2,
          'function': 0,
          'interface': 2,
          'name': 'Waterfall',
          'value': 0,
        }),
        '502': dict({
          'circuit_id': 502,
          'color': dict({
            'color_position': 0,
            'color_set': 2,
            'color_stagger': 2,
          }),
          'configuration': dict({
            'default_runtime': 720,
            'delay': 0,
            'flags': 0,
            'name_index': 62,
            'unknown_at_offset_126': 0,
            'unknown_at_offset_127': 0,
          }),
          'device_id': 3,
          'function': 16,
          'interface': 3,
          'name': 'Pool Light',
          'value': 0,
        }),
        '503': dict({
          'circuit_id': 503,
          'color': dict({
            'color_position': 1,
            'color_set': 6,
            'color_stagger': 10,
          }),
          'configuration': dict({
            'default_runtime': 720,
            'delay': 0,
            'flags': 0,
            'name_index': 73,
            'unknown_at_offset_158': 0,
            'unknown_at_offset_159': 0,
          }),
          'device_id': 4,
          'function': 16,
          'interface': 3,
          'name': 'Spa Light',
          'value': 0,
        }),
        '504': dict({
          'circuit_id': 504,
          'color': dict({
            'color_position': 0,
            'color_set': 0,
            'color_stagger': 0,
          }),
          'configuration': dict({
            'default_runtime': 240,
            'delay': 0,
            'flags': 0,
            'name_index': 21,
            'unknown_at_offset_186': 0,
            'unknown_at_offset_187': 0,
          }),
          'device_id': 5,
          'function': 5,
          'interface': 0,
          'name': 'Cleaner',
          'value': 0,
        }),
        '505': dict({
          'circuit_id': 505,
          'color': dict({
            'color_position': 0,
            'color_set': 0,
            'color_stagger': 0,
          }),
          'configuration': dict({
            'default_runtime': 720,
            'delay': 0,
            'flags': 1,
            'name_index': 63,
            'unknown_at_offset_214': 0,
            'unknown_at_offset_215': 0,
          }),
          'device_id': 6,
          'function': 2,
          'interface': 0,
          'name': 'Pool Low',
          'value': 0,
        }),
        '506': dict({
          'circuit_id': 506,
          'color': dict({
            'color_position': 0,
            'color_set': 0,
            'color_stagger': 0,
          }),
          'configuration': dict({
            'default_runtime': 720,
            'delay': 0,
            'flags': 0,
            'name_index': 91,
            'unknown_at_offset_246': 0,
            'unknown_at_offset_247': 0,
          }),
          'device_id': 7,
          'function': 7,
          'interface': 4,
          'name': 'Yard Light',
          'value': 0,
        }),
        '507': dict({
          'circuit_id': 507,
          'color': dict({
            'color_position': 0,
            'color_set': 0,
            'color_stagger': 0,
          }),
          'configuration': dict({
            'default_runtime': 1620,
            'delay': 0,
            'flags': 0,
            'name_index': 101,
            'unknown_at_offset_274': 0,
            'unknown_at_offset_275': 0,
          }),
          'device_id': 8,
          'function': 0,
          'interface': 2,
          'name': 'Cameras',
          'value': 1,
        }),
        '508': dict({
          'circuit_id': 508,
          'color': dict({
            'color_position': 0,
            'color_set': 0,
            'color_stagger': 0,
          }),
          'configuration': dict({
            'default_runtime': 720,
            'delay': 0,
            'flags': 0,
            'name_index': 61,
            'unknown_at_offset_306': 0,
            'unknown_at_offset_307': 0,
          }),
          'device_id': 9,
          'function': 0,
          'interface': 0,
          'name': 'Pool High',
          'value': 0,
        }),
        '510': dict({
          'circuit_id': 510,
          'color': dict({
            'color_position': 0,
            'color_set': 0,
            'color_stagger': 0,
          }),
          'configuration': dict({
            'default_runtime': 720,
            'delay': 0,
            'flags': 0,
            'name_index': 78,
            'unknown_at_offset_334': 0,
            'unknown_at_offset_335': 0,
          }),
          'device_id': 11,
          'function': 14,
          'interface': 1,
          'name': 'Spillway',
          'value': 0,
        }),
        '511': dict({
          'circuit_id': 511,
          'color': dict({
            'color_position': 0,
            'color_set': 0,
            'color_stagger': 0,
          }),
          'configuration': dict({
            'default_runtime': 720,
            'delay': 0,
            'flags': 0,
            'name_index': 61,
            'unknown_at_offset_366': 0,
            'unknown_at_offset_367': 0,
          }),
          'device_id': 12,
          'function': 0,
          'interface': 5,
          'name': 'Pool High',
          'value': 0,
        }),
      }),
      'controller': dict({
        'configuration': dict({
          'body_type': dict({
            '0': dict({
              'max_setpoint': 104,
              'min_setpoint': 40,
            }),
            '1': dict({
              'max_setpoint': 104,
              'min_setpoint': 40,
            }),
          }),
          'circuit_count': 11,
          'color': list([
            dict({
              'name': 'White',
              'value': list([
                255,
                255,
                255,
              ]),
            }),
            dict({
              'name': 'Light Green',
              'value': list([
                160,
                255,
                160,
              ]),
            }),
            dict({
              'name': 'Green',
              'value': list([
                0,
                255,
                80,
              ]),
            }),
            dict({
              'name': 'Cyan',
              'value': list([
                0,
                255,
                200,
              ]),
            }),
            dict({
              'name': 'Blue',
              'value': list([
                100,
                140,
                255,
              ]),
            }),
            dict({
              'name': 'Lavender',
              'value': list([
                230,
                130,
                255,
              ]),
            }),
            dict({
              'name': 'Magenta',
              'value': list([
                255,
                0,
                128,
              ]),
            }),
            dict({
              'name': 'Light Magenta',
              'value': list([
                255,
                180,
                210,
              ]),
            }),
          ]),
          'color_count': 8,
          'controller_data': 0,
          'controller_type': 13,
          'generic_circuit_name': 'Water Features',
          'hardware_type': 0,
          'interface_tab_flags': 127,
          'is_celsius': dict({
            'name': 'Is Celsius',
            'value': 0,
          }),
          'remotes': 0,
          'show_alarms': 0,
          'unknown_at_offset_09': 0,
          'unknown_at_offset_10': 0,
          'unknown_at_offset_11': 0,
        }),
        'controller_id': 100,
        'date_time': dict({
          'auto_dst': dict({
            'name': 'Automatic Daylight Saving Time',
            'value': 1,
          }),
          'timestamp': 1700489169.0,
          'timestamp_host': 1700517812.0,
        }),
        'equipment': dict({
          'flags': 98360,
          'list': list([
            'INTELLIBRITE',
            'INTELLIFLO_0',
            'INTELLIFLO_1',
            'INTELLICHEM',
            'HYBRID_HEATER',
          ]),
        }),
        'model': dict({
          'name': 'Model',
          'value': 'EasyTouch2 8',
        }),
        'sensor': dict({
          'active_alert': dict({
            'device_type': 'alarm',
            'name': 'Active Alert',
            'value': 0,
          }),
          'air_temperature': dict({
            'device_type': 'temperature',
            'name': 'Air Temperature',
            'state_type': 'measurement',
            'unit': '°F',
            'value': 69,
          }),
          'cleaner_delay': dict({
            'name': 'Cleaner Delay',
            'value': 0,
          }),
          'freeze_mode': dict({
            'name': 'Freeze Mode',
            'value': 0,
          }),
          'orp': dict({
            'name': 'ORP',
            'state_type': 'measurement',
            'unit': 'mV',
            'value': 728,
          }),
          'orp_supply_level': dict({
            'name': 'ORP Supply Level',
            'state_type': 'measurement',
            'value': 3,
          }),
          'ph': dict({
            'name': 'pH',
            'state_type': 'measurement',
            'unit': 'pH',
            'value': 7.61,
          }),
          'ph_supply_level': dict({
            'name': 'pH Supply Level',
            'state_type': 'measurement',
            'value': 2,
          }),
          'pool_delay': dict({
            'name': 'Pool Delay',
            'value': 0,
          }),
          'salt_ppm': dict({
            'name': 'Salt',
            'state_type': 'measurement',
            'unit': 'ppm',
            'value': 0,
          }),
          'saturation': dict({
            'name': 'Saturation Index',
            'state_type': 'measurement',
            'unit': 'lsi',
            'value': 0.06,
          }),
          'spa_delay': dict({
            'name': 'Spa Delay',
            'value': 0,
          }),
          'state': dict({
            'device_type': 'enum',
            'enum_options': list([
              'Unknown',
              'Ready',
              'Sync',
              'Service',
            ]),
            'name': 'Controller State',
            'value': 1,
          }),
        }),
      }),
      'intellichem': dict({
        'alarm': dict({
          'flags': 1,
          'flow_alarm': dict({
            'device_type': 'alarm',
            'name': 'Flow Alarm',
            'value': 1,
          }),
          'orp_high_alarm': dict({
            'device_type': 'alarm',
            'name': 'ORP HIGH Alarm',
            'value': 0,
          }),
          'orp_low_alarm': dict({
            'device_type': 'alarm',
            'name': 'ORP LOW Alarm',
            'value': 0,
          }),
          'orp_supply_alarm': dict({
            'device_type': 'alarm',
            'name': 'ORP Supply Alarm',
            'value': 0,
          }),
          'ph_high_alarm': dict({
            'device_type': 'alarm',
            'name': 'pH HIGH Alarm',
            'value': 0,
          }),
          'ph_low_alarm': dict({
            'device_type': 'alarm',
            'name': 'pH LOW Alarm',
            'value': 0,
          }),
          'ph_supply_alarm': dict({
            'device_type': 'alarm',
            'name': 'pH Supply Alarm',
            'value': 0,
          }),
          'probe_fault_alarm': dict({
            'device_type': 'alarm',
            'name': 'Probe Fault',
            'value': 0,
          }),
        }),
        'alert': dict({
          'flags': 0,
          'orp_limit': dict({
            'name': 'ORP Dose Limit Reached',
            'value': 0,
          }),
          'ph_limit': dict({
            'name': 'pH Dose Limit Reached',
            'value': 0,
          }),
          'ph_lockout': dict({
            'name': 'pH Lockout',
            'value': 0,
          }),
        }),
        'configuration': dict({
          'calcium_harness': dict({
            'max_setpoint': 800,
            'min_setpoint': 25,
            'name': 'Calcium Hardness',
            'unit': 'ppm',
            'value': 800,
          }),
          'cya': dict({
            'max_setpoint': 201,
            'min_setpoint': 0,
            'name': 'Cyanuric Acid',
            'unit': 'ppm',
            'value': 45,
          }),
          'flags': 32,
          'orp_setpoint': dict({
            'max_setpoint': 800,
            'min_setpoint': 400,
            'name': 'ORP Setpoint',
            'unit': 'mV',
            'value': 720,
          }),
          'ph_setpoint': dict({
            'max_setpoint': 7.6,
            'min_setpoint': 7.2,
            'name': 'pH Setpoint',
            'unit': 'pH',
            'value': 7.6,
          }),
          'probe_is_celsius': 0,
          'salt_tds_ppm': dict({
            'max_setpoint': 6500,
            'min_setpoint': 500,
            'name': 'Salt/TDS',
            'unit': 'ppm',
            'value': 1000,
          }),
          'total_alkalinity': dict({
            'max_setpoint': 800,
            'min_setpoint': 25,
            'name': 'Total Alkalinity',
            'unit': 'ppm',
            'value': 45,
          }),
        }),
        'dose_status': dict({
          'flags': 149,
          'orp_dosing_state': dict({
            'device_type': 'enum',
            'enum_options': list([
              'Dosing',
              'Mixing',
              'Monitoring',
            ]),
            'name': 'ORP Dosing State',
            'value': 2,
          }),
          'orp_last_dose_time': dict({
            'device_type': 'duration',
            'name': 'Last ORP Dose Time',
            'state_type': 'total_increasing',
            'unit': 'sec',
            'value': 4,
          }),
          'orp_last_dose_volume': dict({
            'device_type': 'volume',
            'name': 'Last ORP Dose Volume',
            'state_type': 'total_increasing',
            'unit': 'mL',
            'value': 8,
          }),
          'ph_dosing_state': dict({
            'device_type': 'enum',
            'enum_options': list([
              'Dosing',
              'Mixing',
              'Monitoring',
            ]),
            'name': 'pH Dosing State',
            'value': 1,
          }),
          'ph_last_dose_time': dict({
            'device_type': 'duration',
            'name': 'Last pH Dose Time',
            'state_type': 'total_increasing',
            'unit': 'sec',
            'value': 5,
          }),
          'ph_last_dose_volume': dict({
            'device_type': 'volume',
            'name': 'Last pH Dose Volume',
            'state_type': 'total_increasing',
            'unit': 'mL',
            'value': 8,
          }),
        }),
        'firmware': dict({
          'major': 1,
          'minor': 60,
          'name': 'IntelliChem Firmware',
          'value': '1.060',
        }),
        'sensor': dict({
          'orp_now': dict({
            'name': 'ORP Now',
            'state_type': 'measurement',
            'unit': 'mV',
            'value': 0,
          }),
          'orp_supply_level': dict({
            'name': 'ORP Supply Level',
            'state_type': 'measurement',
            'value': 3,
          }),
          'ph_now': dict({
            'name': 'pH Now',
            'state_type': 'measurement',
            'unit': 'pH',
            'value': 0.0,
          }),
          'ph_probe_water_temp': dict({
            'device_type': 'temperature',
            'name': 'pH Probe Water Temperature',
            'state_type': 'measurement',
            'unit': '°F',
            'value': 81,
          }),
          'ph_supply_level': dict({
            'name': 'pH Supply Level',
            'state_type': 'measurement',
            'value': 2,
          }),
          'saturation': dict({
            'name': 'Saturation Index',
            'state_type': 'measurement',
            'unit': 'lsi',
            'value': 0.06,
          }),
        }),
        'unknown_at_offset_00': 42,
        'unknown_at_offset_04': 0,
        'unknown_at_offset_44': 0,
        'unknown_at_offset_45': 0,
        'unknown_at_offset_46': 0,
        'water_balance': dict({
          'corrosive': dict({
            'device_type': 'alarm',
            'name': 'SI Corrosive',
            'value': 0,
          }),
          'flags': 0,
          'scaling': dict({
            'device_type': 'alarm',
            'name': 'SI Scaling',
            'value': 0,
          }),
        }),
      }),
      'pump': dict({
        '0': dict({
          'data': 70,
          'gpm_now': dict({
            'name': 'Pool Low Pump GPM Now',
            'state_type': 'measurement',
            'unit': 'gpm',
            'value': 0,
          }),
          'preset': dict({
            '0': dict({
              'device_id': 6,
              'is_rpm': 0,
              'setpoint': 63,
            }),
            '1': dict({
              'device_id': 9,
              'is_rpm': 0,
              'setpoint': 72,
            }),
            '2': dict({
              'device_id': 1,
              'is_rpm': 1,
              'setpoint': 3450,
            }),
            '3': dict({
              'device_id': 130,
              'is_rpm': 0,
              'setpoint': 75,
            }),
            '4': dict({
              'device_id': 12,
              'is_rpm': 0,
              'setpoint': 72,
            }),
            '5': dict({
              'device_id': 0,
              'is_rpm': 0,
              'setpoint': 30,
            }),
            '6': dict({
              'device_id': 0,
              'is_rpm': 0,
              'setpoint': 30,
            }),
            '7': dict({
              'device_id': 0,
              'is_rpm': 0,
              'setpoint': 30,
            }),
          }),
          'rpm_now': dict({
            'name': 'Pool Low Pump RPM Now',
            'state_type': 'measurement',
            'unit': 'rpm',
            'value': 0,
          }),
          'state': dict({
            'name': 'Pool Low Pump',
            'value': 0,
          }),
          'type': 3,
          'unknown_at_offset_16': 0,
          'unknown_at_offset_24': 255,
          'watts_now': dict({
            'device_type': 'power',
            'name': 'Pool Low Pump Watts Now',
            'state_type': 'measurement',
            'unit': 'W',
            'value': 0,
          }),
        }),
        '1': dict({
          'data': 66,
          'gpm_now': dict({
            'name': 'Waterfall Pump GPM Now',
            'state_type': 'measurement',
            'unit': 'gpm',
            'value': 0,
          }),
          'preset': dict({
            '0': dict({
              'device_id': 2,
              'is_rpm': 1,
              'setpoint': 2700,
            }),
            '1': dict({
              'device_id': 0,
              'is_rpm': 0,
              'setpoint': 30,
            }),
            '2': dict({
              'device_id': 0,
              'is_rpm': 0,
              'setpoint': 30,
            }),
            '3': dict({
              'device_id': 0,
              'is_rpm': 0,
              'setpoint': 30,
            }),
            '4': dict({
              'device_id': 0,
              'is_rpm': 0,
              'setpoint': 30,
            }),
            '5': dict({
              'device_id': 0,
              'is_rpm': 0,
              'setpoint': 30,
            }),
            '6': dict({
              'device_id': 0,
              'is_rpm': 0,
              'setpoint': 30,
            }),
            '7': dict({
              'device_id': 0,
              'is_rpm': 0,
              'setpoint': 30,
            }),
          }),
          'rpm_now': dict({
            'name': 'Waterfall Pump RPM Now',
            'state_type': 'measurement',
            'unit': 'rpm',
            'value': 0,
          }),
          'state': dict({
            'name': 'Waterfall Pump',
            'value': 0,
          }),
          'type': 3,
          'unknown_at_offset_16': 0,
          'unknown_at_offset_24': 255,
          'watts_now': dict({
            'device_type': 'power',
            'name': 'Waterfall Pump Watts Now',
            'state_type': 'measurement',
            'unit': 'W',
            'value': 0,
          }),
        }),
        '2': dict({
          'data': 0,
        }),
        '3': dict({
          'data': 0,
        }),
        '4': dict({
          'data': 0,
        }),
        '5': dict({
          'data': 0,
        }),
        '6': dict({
          'data': 0,
        }),
        '7': dict({
          'data': 0,
        }),
      }),
      'scg': dict({
        'configuration': dict({
          'pool_setpoint': dict({
            'body_type': 0,
            'max_setpoint': 100,
            'min_setpoint': 0,
            'name': 'Pool Chlorinator Setpoint',
            'step': 5,
            'unit': '%',
            'value': 51,
          }),
          'spa_setpoint': dict({
            'body_type': 1,
            'max_setpoint': 100,
            'min_setpoint': 0,
            'name': 'Spa Chlorinator Setpoint',
            'step': 5,
            'unit': '%',
            'value': 0,
          }),
          'super_chlor_timer': dict({
            'max_setpoint': 72,
            'min_setpoint': 1,
            'name': 'Super Chlorination Timer',
            'step': 1,
            'unit': 'hr',
            'value': 0,
          }),
        }),
        'flags': 0,
        'scg_present': 0,
        'sensor': dict({
          'salt_ppm': dict({
            'name': 'Chlorinator Salt',
            'state_type': 'measurement',
            'unit': 'ppm',
            'value': 0,
          }),
          'state': dict({
            'name': 'Chlorinator',
            'value': 0,
          }),
        }),
        'super_chlorinate': dict({
          'name': 'Super Chlorinate',
          'value': 0,
        }),
      }),
    }),
    'debug': dict({
    }),
  })
# ---