Output for `Field.dataset_compliance` towards a CF Checker

[sadielbartholomew]

We are planning to update the current dataset_compliance method available on a Field (or its Domain) to provide as its output a complete and general summary of the CF Conventions compliance of the Field in line with the canonical Conformance document. The output encoding this information would be machine-readable in some agreed and easily-parsable structure, which could then be processed to produce a human-digestible report (and even fancier views such as graphs with nodes for families of variables and attributes etc. leading to ultimate reasons for non-compliance), for example as served up on a browser page as with the (lately necessarily unmaintained) NCAS/CEDA CF Checker.

This has been in discussion over the past month or so, with a PR in preparation for a bit longer than that, but I will use this Issue to register our plans and to house any discussion on converging towards a design for the final data structure for the output of the dataset_compliance method. (This saves from needing to open the PR in preparation pre-maturely in draft form.)

Data structure for output

After some discussions over the past month we've agreed - as I understand it, please correct me if anything seems amiss etc. - that the structure should be as follows, using to illustrate two field examples, one a non-UGRID field and the other a UGRID field (as per EXPECT project focus), the data structure we want to emerge is as follows, with notable features/points being:

• information about intermediate variables was previously not registered in the output - we want to include it those to clarify the relationship between attributes which have problems noted;
• we address the above with a nesting structure whereby variables are keys against an objects_dict (see below 'Code to generate') noting problems with attributes and/or dimensions, and either of the latter are keys against a reason_dict (see also below) having reasons registered either as a nested list of dicts or, eventually, a string value, along with the value of the attribute itself (and a code corresponding to the issue, only if the reason is a singular string case);
• we (sadly) have to use a list of dicts for reasons as per the above point, rather than a simple dict with multiple items as individual keys, because for (at least) the case of cell methods, there is no variable to register an issue under - so we'd need a way to register a reason_dict without anything to key it under, and a list seems most appropriate;
• the CF version checked for compliance against only needs to be noted once, at the top-level - not repeated throughout the structure as-is with the present prototype in main.

General structure

If a field itself and one of the attributes defined on it had a bad standard name, the following would represent this, noting I have only populated the 'attributes' parts of the structure for demonstration, where the 'dimensions' keys would have similar structure to register dimensional issues:

{'the_field_variable': {'CF_version': '1.12',
                        'attributes': [{'standard_name': {'code': 0,
                                                          'reason': 'some '
                                                                    'string '
                                                                    'reason '
                                                                    'e.g. bad '
                                                                    'standard '
                                                                    'name',
                                                          'value': None}},
                                       {'an_attribute': {'reason': {'child_variable': {'attributes': [{'standard_name': {'code': 0,
                                                                                                                         'reason': 'some '
                                                                                                                                   'string '
                                                                                                                                   'reason '
                                                                                                                                   'e.g. '
                                                                                                                                   'bad '
                                                                                                                                   'standard '
                                                                                                                                   'name',
                                                                                                                         'value': None}}],
                                                                                       'dimension_sizes': {},
                                                                                       'dimensions': []}},
                                                         'value': None}}],
                        'dimension_sizes': {},
                        'dimensions': []}}

Examples

Example UGRID field

{'pa': {'CF_version': '1.12',
        'attributes': [{'standard_name': {'code': 0,
                                          'reason': 'some string reason e.g. '
                                                    'bad standard name',
                                          'value': None}},
                       {'mesh': {'reason': {'Mesh2': {'attributes': [{'standard_name': {'code': 0,
                                                                                        'reason': 'some '
                                                                                                  'string '
                                                                                                  'reason '
                                                                                                  'e.g. '
                                                                                                  'bad '
                                                                                                  'standard '
                                                                                                  'name',
                                                                                        'value': None}},
                                                                     {'edge_node_connectivity': {'reason': {'Mesh2_edge_nodes': {'attributes': [{'standard_name': {'code': 0,
                                                                                                                                                                   'reason': 'some '
                                                                                                                                                                             'string '
                                                                                                                                                                             'reason '
                                                                                                                                                                             'e.g. '
                                                                                                                                                                             'bad '
                                                                                                                                                                             'standard '
                                                                                                                                                                             'name',
                                                                                                                                                                   'value': None}}],
                                                                                                                                 'dimension_sizes': {},
                                                                                                                                 'dimensions': []}},
                                                                                                 'value': None}},
                                                                     {'face_face_connectivity': {'reason': {'Mesh2_face_links': {'attributes': [{'standard_name': {'code': 0,
                                                                                                                                                                   'reason': 'some '
                                                                                                                                                                             'string '
                                                                                                                                                                             'reason '
                                                                                                                                                                             'e.g. '
                                                                                                                                                                             'bad '
                                                                                                                                                                             'standard '
                                                                                                                                                                             'name',
                                                                                                                                                                   'value': None}}],
                                                                                                                                 'dimension_sizes': {},
                                                                                                                                 'dimensions': []}},
                                                                                                 'value': None}},
                                                                     {'face_node_connectivity': {'reason': {'Mesh2_face_nodes': {'attributes': [{'standard_name': {'code': 0,
                                                                                                                                                                   'reason': 'some '
                                                                                                                                                                             'string '
                                                                                                                                                                             'reason '
                                                                                                                                                                             'e.g. '
                                                                                                                                                                             'bad '
                                                                                                                                                                             'standard '
                                                                                                                                                                             'name',
                                                                                                                                                                   'value': None}}],
                                                                                                                                 'dimension_sizes': {},
                                                                                                                                 'dimensions': []}},
                                                                                                 'value': None}}],
                                                      'dimension_sizes': {},
                                                      'dimensions': []}},
                                 'value': None}}],
        'dimension_sizes': {},
        'dimensions': []}}

Example non-UGRID field

Say there were some bad standard names: on the variable corresponding to the field itself, something under the ancil variable, a cell measure, and some orogoraphy related variables:

{'ta': {'CF_version': '1.12',
        'attributes': [{'standard_name': {'code': 0,
                                          'reason': 'some string reason e.g. '
                                                    'bad standard name',
                                          'value': None}},
                       {'ancillary_variables': {'reason': {'air_temperature_standard_error': {'attributes': [{'standard_name': {'code': 0,
                                                                                                                                'reason': 'some '
                                                                                                                                          'string '
                                                                                                                                          'reason '
                                                                                                                                          'e.g. '
                                                                                                                                          'bad '
                                                                                                                                          'standard '
                                                                                                                                          'name',
                                                                                                                                'value': None}}],
                                                                                              'dimension_sizes': {},
                                                                                              'dimensions': []}},
                                                'value': None}},
                       {'cell_measures': {'reason': {'cell_measure': {'attributes': [{'standard_name': {'code': 0,
                                                                                                        'reason': 'some '
                                                                                                                  'string '
                                                                                                                  'reason '
                                                                                                                  'e.g. '
                                                                                                                  'bad '
                                                                                                                  'standard '
                                                                                                                  'name',
                                                                                                        'value': None}}],
                                                                      'dimension_sizes': {},
                                                                      'dimensions': []}},
                                          'value': None}},
                       {'surface_altitude': {'reason': {'x': {'attributes': [{'standard_name': {'code': 0,
                                                                                                'reason': 'some '
                                                                                                          'string '
                                                                                                          'reason '
                                                                                                          'e.g. '
                                                                                                          'bad '
                                                                                                          'standard '
                                                                                                          'name',
                                                                                                'value': None}}],
                                                              'dimension_sizes': {},
                                                              'dimensions': []},
                                                        'y': {'attributes': [{'standard_name': {'code': 0,
                                                                                                'reason': 'some '
                                                                                                          'string '
                                                                                                          'reason '
                                                                                                          'e.g. '
                                                                                                          'bad '
                                                                                                          'standard '
                                                                                                          'name',
                                                                                                'value': None}}],
                                                              'dimension_sizes': {},
                                                              'dimensions': []}},
                                             'value': None}}],
        'dimension_sizes': {},
        'dimensions': []}}

Code to generate data structure cases above for ease of editing

from pprint import pprint

reason_dict = {"reason": {}, "value": None}
# Use None and 0 as placeholders for actual code value and 'value' value
reason_dict_end = {
    "reason": "some string reason e.g. bad standard name",
    "code": 0,
    "value": None
}
objects_dict = {
    # Not showing in this demo, but basically dimension names as keys with
    # sizes as values, a simple non-nested dict structure.
    "dimension_sizes": {},
    # Lists of dicts of relevant object info. in a congruous way
    "dimensions": [],
    "attributes": [],   
}


def populate_reason_dict(set_reason_info):
    d = reason_dict.copy()

    # Ignore values (singular) for this demo which are only to indicate the
    # structure
    d["reason"] = set_reason_info

    return d


def populate_objects_dict(
        set_attrs_info, set_dims_info=False, set_dims_sizes=False,
        is_top_level=False,
):
    d = objects_dict.copy()
    if is_top_level:
        d["CF_version"] = "1.12"  # placeholder for actual value

    if set_attrs_info:
        d["attributes"] = set_attrs_info
    if set_dims_info:
        d["dimensions"] = set_dims_info

    return d


general_idea = {
       "the_field_variable": populate_objects_dict(
        [
            {"standard_name": reason_dict_end},
            {
                "an_attribute": populate_reason_dict(
                    {
                        "child_variable": populate_objects_dict(
                            [
                                {"standard_name": reason_dict_end},
                            ]
                        )
                    }
                )
            },
        ], is_top_level=True,
    ),
}

non_ugrid_bad_names_example = {
    "ta": populate_objects_dict(
        [
            {"standard_name": reason_dict_end},
            {"ancillary_variables": populate_reason_dict(
                {
                "air_temperature_standard_error": populate_objects_dict(
                    [{"standard_name": reason_dict_end}]
                )
                }
            )},
            {"cell_measures": populate_reason_dict(
                {
                "cell_measure": populate_objects_dict(
                    [{"standard_name": reason_dict_end}]
                )
                }
            )},
            {"surface_altitude": populate_reason_dict(
                {
                "x": populate_objects_dict(
                    [{"standard_name": reason_dict_end}]
                ),
                "y": populate_objects_dict(
                    [{"standard_name": reason_dict_end}]
                )
                },
            )},
        ], is_top_level=True,
    ),
}

ugrid_bad_names_example = {
    "pa": populate_objects_dict(
        [
            {"standard_name": reason_dict_end},
            {
                "mesh": populate_reason_dict(
                    {
                        "Mesh2": populate_objects_dict(
                            [
                                {"standard_name": reason_dict_end},
                                {
                                    "edge_node_connectivity": populate_reason_dict(
                                        {
                                            "Mesh2_edge_nodes": populate_objects_dict(
                                                [{"standard_name": reason_dict_end}]
                                            )
                                        }
                                    )
                                },
                                {
                                    "face_face_connectivity": populate_reason_dict(
                                        {
                                            "Mesh2_face_links": populate_objects_dict(
                                                [{"standard_name": reason_dict_end}]
                                            )
                                        }
                                    )
                                },
                                {
                                    "face_node_connectivity": populate_reason_dict(
                                        {
                                            "Mesh2_face_nodes": populate_objects_dict(
                                                [{"standard_name": reason_dict_end}]
                                            )
                                        }
                                    )
                                },
                            ]
                        )
                    }
                )
            },
        ], is_top_level=True,
    ),
}

print("\nGeneral idea is:\n")
pprint(general_idea)

print(
    "\nResult, desired data structure, for non-UGRID bad named field "
    "case is:\n"
)
pprint(non_ugrid_bad_names_example)

print(
    "\nResult, desired data structure, for UGRID bad named field case "
    "is:\n"
)
pprint(ugrid_bad_names_example)

[sadielbartholomew]

I am probably getting a bit ahead of myself, thinking about cool ways we can showcase compliance issues via visualisations, TUIs and such, but also to help illustrate the data structure here - I had a nice half-hour or so 'vibe code' session to use NetworkX to visualise the structures in a way which highlights the variables, attributes and inheritance structure, ultimately leading to the final 'reasons' for non-compliance. Ultimately I have some code which takes as an input the data structures above and produces the following (static) concentric graphical view:

Visualising the output from the example data structures above

General structure

Examples

Example UGRID field

Example non-UGRID field

[sadielbartholomew]

We have thought of several edge cases which sadly complicate the structural needs and therefore need to update or rethink the structure above. In due course I will write out a table of these edge cases to specify how they complicate things and what is needed in terms of a structure to accommodate them.

For now, given we've spoken about this offline @davidhassell, my new idea is as follows (using a similar form of creation as my original comment, and with the same UGRID example field):

New idea for structure

This is a bit more nested than the former case, but should be more flexible and makes it certain which object name quoted is a variable, attribute or dimension. The core objects are a components dict detailing any sub-components and any issue present on the current object, and an issues dict detailed issue(s) or information relating to those, as detailed in the generating code at the bottom.

Some important notes:

• Though I note that there is only the possibility for object relationships of:
  • attribute -> variable, attribute or dimension;
  • dimension -> dimension (never an attribute or variable);
  • variable -> attribute;
    having a dict with all three potential sub-components is flexible to account for any such mapping where a missing key or None value can imply 'not applicable'. It keeps the structuring consistent.
• To cater for cases where an object refers to multiple others e.g. an attribute referring to multiple variables, I suggest we have a reference e.g. _issues: ["reference:<variable>",] or some way to imply 'already registered elsewhere', consult that - rather than duplicate the problem. And the code logic can account for this by following the reference.
• For issues with dimensions, though I haven't shown it in the structures below, the lone value representing a size is replaced by an _issues dict containing the value as a keyed element as usual, as well as detailed the issue. Ohterwise all dimensions are present as keys with size values - unlike attributes and variables which only appear if there is an issue on them or a child.

General idea

{'<field_variable_name>': {'_issues': [],
                           'attributes': {'<attr_1>': {'_issues': [{'code': 0,
                                                                    'reason': 'reason '
                                                                              'for '
                                                                              'badness',
                                                                    'size': 0,
                                                                    'value': 'value '
                                                                             'string'}],
                                                       'attributes': None,
                                                       'dimensions': None,
                                                       'variables': {'<variable_1>': {'_issues': [{'code': 0,
                                                                                                   'reason': 'reason '
                                                                                                             'for '
                                                                                                             'badness',
                                                                                                   'size': 0,
                                                                                                   'value': 'value '
                                                                                                            'string'}],
                                                                                      'attributes': None,
                                                                                      'dimensions': {'<dimension_1>': 10},
                                                                                      'variables': {'<child_variable_1>': {'_issues': [],
                                                                                                                           'attributes': {'<attr_1>': {'code': 0,
                                                                                                                                                       'reason': 'reason '
                                                                                                                                                                 'for '
                                                                                                                                                                 'badness',
                                                                                                                                                       'size': 0,
                                                                                                                                                       'value': 'value '
                                                                                                                                                                'string'},
                                                                                                                                          'standard_name': {'code': 0,
                                                                                                                                                            'reason': 'bad '
                                                                                                                                                                      'standard '
                                                                                                                                                                      'name',
                                                                                                                                                            'size': 0,
                                                                                                                                                            'value': 'value '
                                                                                                                                                                     'string'}},
                                                                                                                           'dimensions': None,
                                                                                                                           'variables': None}}}}},
                                          'standard_name': {'code': 0,
                                                            'reason': 'bad '
                                                                      'standard '
                                                                      'name',
                                                            'size': 0,
                                                            'value': 'value '
                                                                     'string'}},
                           'dimensions': {'<dimension_1>': 10,
                                          '<dimension_2>': 20},
                           'variables': None},
 'CF_Version': '1.12'}

UGRID example (for same field as original comment, to compare)

{'CF_Version': '1.12',
 'pa': {'_issues': [],
        'attributes': {'mesh': {'_issues': [{'code': 0,
                                             'reason': 'reason for badness',
                                             'size': 0,
                                             'value': 'value string'}],
                                'attributes': None,
                                'dimensions': None,
                                'variables': {'Mesh2': {'_issues': [{'code': 0,
                                                                     'reason': 'reason '
                                                                               'for '
                                                                               'badness',
                                                                     'size': 0,
                                                                     'value': 'value '
                                                                              'string'}],
                                                        'attributes': {'edge_node_connectivity': {'_issues': [],
                                                                                                  'attributes': None,
                                                                                                  'dimensions': None,
                                                                                                  'variables': {'Mesh2_edge_nodes': {'_issues': [],
                                                                                                                                     'attributes': {'standard_name': {'code': 0,
                                                                                                                                                                      'reason': 'bad '
                                                                                                                                                                                'standard '
                                                                                                                                                                                'name',
                                                                                                                                                                      'size': 0,
                                                                                                                                                                      'value': 'value '
                                                                                                                                                                               'string'}},
                                                                                                                                     'dimensions': None,
                                                                                                                                     'variables': None}}},
                                                                       'face_face_connectivity': {'_issues': [],
                                                                                                  'attributes': None,
                                                                                                  'dimensions': None,
                                                                                                  'variables': {'Mesh2_face_links': {'_issues': [],
                                                                                                                                     'attributes': {'standard_name': {'code': 0,
                                                                                                                                                                      'reason': 'bad '
                                                                                                                                                                                'standard '
                                                                                                                                                                                'name',
                                                                                                                                                                      'size': 0,
                                                                                                                                                                      'value': 'value '
                                                                                                                                                                               'string'}},
                                                                                                                                     'dimensions': None,
                                                                                                                                     'variables': None}}},
                                                                       'face_node_connectivity': {'_issues': [],
                                                                                                  'attributes': None,
                                                                                                  'dimensions': None,
                                                                                                  'variables': {'Mesh2_face_nodes': {'_issues': [],
                                                                                                                                     'attributes': {'standard_name': {'code': 0,
                                                                                                                                                                      'reason': 'bad '
                                                                                                                                                                                'standard '
                                                                                                                                                                                'name',
                                                                                                                                                                      'size': 0,
                                                                                                                                                                      'value': 'value '
                                                                                                                                                                               'string'}},
                                                                                                                                     'dimensions': None,
                                                                                                                                     'variables': None}}}},
                                                        'dimensions': {'<dimension_1>': 10},
                                                        'variables': None}}},
                       'standard_name': {'code': 0,
                                         'reason': 'bad standard name',
                                         'size': 0,
                                         'value': 'value string'}},
        'dimensions': {'<dimension_1>': 10,
                       '<dimension_2>': {'code': 0,
                                         'reason': 'bad standard name',
                                         'size': 0,
                                         'value': 'value string'}},
        'variables': None}}

Code to generate these

from pprint import pprint
from copy import deepcopy

# Fixes two issues: avoid list of dicts, avoid dimensions on multiple
# levels

# Details issues with any given component, with value or size information
# as appropriate. List caters for any number of issues, but use only one to
# demonstrate
issue_dict = {
    "reason": "reason string",
    "code": 0,
    "value": "value string",  # if an attr, else no such key
    "size": 0,  # if a dim, else no such key
}
###root_dict = {"components": None, "issues": {}}
# Two core dicts which are nested to contain all required information
# Details netCDF components and their hierarchy and mappings/relationships
components_dict = {
    "_issues": [],  # or as a dict, keyed by code?
    "variables": None,  # None if n/a, or dict
    "attributes": None,  # None if n/a, or dict
    "dimensions": None,  # None if n/a, or dict
}


def populate_components_dict(
        issues=False, variables=False, attributes=False, dimensions=False):
    d = deepcopy(components_dict)

    # Ignore values (singular) for this demo which are only to indicate the
    # structure
    if issues:
        d["_issues"].append(issues)  # new key to register issue(s)

    # Sub-components
    if variables:
        d["variables"] = variables
    if attributes:
        d["attributes"] = attributes
    if dimensions:
        d["dimensions"] = dimensions

    return d


def populate_issue_dict(reason):
    i = issue_dict.copy()
    i["reason"] = reason
    return i


general_idea = {
    "CF_Version": "1.12",  # only at top level, injected at end
    "<field_variable_name>": populate_components_dict(
        # no top level field issues, but we don't know what is top-level
        # fieldin processing anyway
        variables={},
        dimensions={"<dimension_1>": 10, "<dimension_2>": 20},
        attributes={
            "standard_name": populate_issue_dict("bad standard name"),
            "<attr_1>":
            populate_components_dict(
                issues=populate_issue_dict("reason for badness"),
                variables={
                    "<variable_1>":
                populate_components_dict(
                    issues=populate_issue_dict("reason for badness"),
                    variables={
                        "<child_variable_1>":
                        populate_components_dict(
                            variables={},
                            attributes={
                                "standard_name": populate_issue_dict("bad standard name"),
                                "<attr_1>": populate_issue_dict("reason for badness"),
                            },
                        ),
                    },
                    attributes={},
                    dimensions={"<dimension_1>": 10},
                ),
            },
                attributes={},
            ),
        },
    ),
}


ugrid_bad_names_example = {
    "CF_Version": "1.12",  # only at top level, injected at end
    "pa": populate_components_dict(
        # no top level field issues, but we don't know what is top-level
        # fieldin processing anyway
        variables={},
        dimensions={"<dimension_1>": 10, "<dimension_2>": populate_issue_dict("bad standard name")},
        attributes={
            "standard_name": populate_issue_dict("bad standard name"),
            "mesh":
            populate_components_dict(
                issues=populate_issue_dict("reason for badness"),
                variables={
                    "Mesh2":
                populate_components_dict(
                    issues=populate_issue_dict("reason for badness"),
                    variables={},
                    attributes={
                        "edge_node_connectivity":
                        populate_components_dict(
                            variables={
                                "Mesh2_edge_nodes": populate_components_dict(
                                    attributes={
                                        "standard_name": populate_issue_dict("bad standard name")
                                    }
                                ),
                            },
                            attributes={}
                        ),
                        "face_face_connectivity":
                        populate_components_dict(
                            variables={
                                "Mesh2_face_links": populate_components_dict(
                                    attributes={
                                        "standard_name": populate_issue_dict("bad standard name")
                                    }
                                ),
                            },
                        ),
                        "face_node_connectivity":
                        populate_components_dict(
                            variables={
                                "Mesh2_face_nodes": populate_components_dict(
                                    attributes={
                                        "standard_name": populate_issue_dict("bad standard name")
                                    }
                                ),
                            },
                            attributes={},
                        ),
                    },
                    dimensions={"<dimension_1>": 10},
                ),
            },
                attributes={},
            ),
        },
    ),
}


print("\nGeneral idea is:\n")
pprint(general_idea)
print("\nUGRID example is:\n")
pprint(ugrid_bad_names_example)

[sadielbartholomew]

An update from the previous comment after recent offline discussion between @davidhassell and I. In light of noted complications and edge cases regarding fully general reporting of non-compliance issues, preserving the relationships between netCDF components of relevance, and deficiencies remaining with the other ideas we had including the above, we decided to use a data model approach to guide us to the right data structure.

We think we are now happy with the structure as one that is suitable for the general case - storing any non-compliance issue that can be determined, in a logical hierarchical way. I am in the process of updating my PR to abide by this - now anticipating perhaps minor tweaks but otherwise no major structural revamp.

In particular, improvements of this new approach relative to those proposed above are:

• there is no ambiguity as to what is a variable, a dimension and an attribute, since all of these objects are stored under the relevant key (e.g. in the initial suggestion variables weren't stored under 'variable' or similar as a key, so it was left as implicit information);
• we restrict the inclusion under one netCDF component to only what is suitable (see 'Underlying structures' - e.g. in my suggestion above in Output for Field.dataset_compliance towards a CF Checker #365 (comment) there were some redundant keys to preserve symmetry, but those weren't useful in hindsight).

Data model approach

UML diagram and code to generate courtesy of @davidhassell and posted on his behalf.

UML

Code to generate UML above (in case of edits)

@startuml

set namespaceSeparator none

skinparam linetype ortho

package CF_conformance {
class "Conventions" {
  {field} The CF conventions being checked 
  {method} 1 conventions
}

class "Variable"{
  {field} Non-conformance related to attributes or dimensions of a variable
  {method} 1 variable name
}
note top of Variable : No Attributes or Dimensions\nimplies Variable conformance
  
class "Dimension" {
  {field} Non-conformance related to the name, size,\nor coordinate variable of a dimension
  {method} 1 dimension name
  {method} 0..1 dimension size
  {method} 0..1 non-conformance reason
}
note "Must have exactly one of\nDimension or reason" as ND
Dimension .. ND

class "Attribute" {
  {field} Non-conformance related to an attribute
  {method} 1 attribute name
  {method} 1 attribute value
  {method} 0..1 non-conformance reason
}
note "Must have exactly one of\nVariable, Dimension, or reason" as NA
Attribute .. NA

"Conventions" *--> "1" "Variable"
"Variable" *--> "0..*" "Attribute"
"Variable" *--> "0..*" "Dimension"
"Attribute" *--> "0..1" "Variable"
"Attribute" *--> "0..1" "Dimension"
"Dimension" *--> "0..1" "Variable"
}

@enduml

Underlying structures

The above leads itself to data structures to combine to store compliance issues:

• one each for the three netCDF component types;
• and a top-level structure to hold the core context, namely the Conventions version governing the report and field variable name as the top-level key holding all issue reporting.

This is not too dissimilar to what I suggested in my comment immediately above, but we restrict the inclusion under one netCDF component to only what is suitable, namely instead of (-> indicates descending the issue storage hierarchy) from my generic suggestion in #365 (comment):

any component- > any other component, e.g:
var -> var, attr, dim
attr -> var, attr, dim
dim -> var, attr, dim

we now create separate dicts to cover only possibilities based on the data model:

var -> attr, dim
attr -> var, dim
dim -> var

Notice there is symmetry where: component 1 -> component 2, component 3, except for the case of dims where they can only map to a var, not an attr (and even the var case is somewhat of an edge case to cover the case of an issue on a dimension where the connection is only through a parent variable dimension.

The four components are:

top_level_dict = {
    "Conventions": "CF-1.13",
    "<field_var_name>": <compliance issue dict composed of the below>,  # dict
}

# *Variable dict*
var_dict = {
    "<a_var_name>": {
        "attributes": [<attr_dict>],  # optional
        "dimensions": [<dim_dict>],  # optional
    }
}

# *Attribute dict*
attr_dict = {
    "<an_attr_name>": [
        {
            "variables": <var_dict>,  # optional
            "dimensions": [<dim_dict>],  # optional
            "value": "some value",  # string
            "reason": "some reason",  # optional
            "code": 0,  # optional
        },
    ]
}

# *Dimension dict*
dim_dict = {
    "<a_dim_name>": [
        {
            "variables": <var_dict>,  # optional
            "size": "some size",  # int or None
            "reason": "some reason",  # optional
            "code": 0,  # optional
        },
    ]
}

Examples to illustrate

Also mostly courtesy of @davidhassell, though in line with outcomes of our discussions I've made some edits (any mistakes are probably my own!). Say the field variable is called 'tas', then we want/expect the following dataset_compliance outputs when there is the case of full compliance and three illustrative possibilities of non-compliance (numbered to aid any further discussion required):

# 1. CF compliant, at v1.13:
compliant_res = {
    "Conventions": "CF-1.13",
    "tas": {},
}


# 2. Bad standard name, otherwise compliant
bad_sn_res = {
    "Conventions": "CF-1.13",
    "tas": {
        "attributes": {
            "standard_name": [
                {"value": "BAD_NAME", "reason": "Invalid standard name"}
            ]
        }
    },
}


# 3. Bad standard name AND cell measures with bad standard name AND bad key AND
#    spans wrong dimension
multi_noncompliance_res = {
    "tas": {
        "attributes": {
            "standard_name": [
                {"value": "BAD_NAME", "reason": "Invalid standard name"}
            ],
            "cell_measures": [
                {"value": "BAD_KEY: areacell", "reason": "bad measure key"},
                {
                    "value": "BAD_KEY: areacell",
                    "variables": {
                        "areacell": {
                            "attributes": {
                                "standard_name": [
                                    {
                                        "value": "BAD_NAME",
                                        "reason": "Invalid standard name",
                                    }
                                ]
                            },
                            "dimensions": {
                                "BAD_DIM": [
                                    {
                                        "size": None,
                                        "reason": "dimension mismatch with field",
                                    }
                                ]
                            },
                        }
                    },
                },
            ],
        }
    }
}

# 4. Bad lat standard name when connection is only through a parent variable
#    dimension
bad_attr_only_via_parent_var_dim = {
    "tas": {
        "dimensions": {
            "lat": [
                {
                    "size": 180,
                    "variables": {
                        "lat": {
                            "attributes": {
                                "standard_name": [
                                    {"value": "BAD_NAME", "reason": "invalid name"}
                                ]
                            }
                        }
                    },
                }
            ]
        }
    }
}

[sadielbartholomew]

Update (esp. for after the Christmas/NY break): we have since the previous post revised the data model a 'lil, corresponding to the following UML (Again thanks to @davidhassell).

I am updating the PR #373 (up in draft) for this, including the aim to move from the functional and procedural approach to object oriented with a new sub-module holding modules each with classes corresponding to the UML classes, with appropriate functionality contained therein (this will be cleaner and more flexible etc. - I wasn't sure if it was necessary at first but might as well get a proper OO structure sorted for future).

UML

Note the main changes since the previous version in the comment above are:

• variable classes may now be associated with a non-conformance;
• non-conformance is now its own class, at least one of which is associated with all dimension and attribute classes, and optionally a variable class (now, as above point);
• some cardinalities we noticed were wrong in the last diagram have been fixed.

Code to generate UML above

@startuml

set namespaceSeparator none

skinparam linetype ortho

package CF-conformance {
  class "Data/Domain variable" {
    {field} A data or domain variable
    {method} 1 Conventions
  }
  
  class "Variable"{
    {field} Non-conformances related to the existence, attributes or dimensions of a variable
    {method} 1 variable name
  }
  
  class "Dimension" {
    {field} Non-conformances related to the\nexistence, name, size, or coordinate variable of a dimension
    {method} 1 dimension name
    {method} 0..1 dimension size
  }
  
  class "Attribute" {
    {field} Non-conformances related to the\nexistence or value of an attribute
    {method} 1 attribute name
    {method} 0..1 attribute value
  }
  
  class "Non-conformance" {
    {field} Non-conformances 
    {method} 1 Description of non-conformance
  }

  "Data/Domain variable" ---|> "Variable"
  "Variable" *--> "0..*" "Attribute"
  "Variable" *--> "0..*" "Dimension"

  "Attribute" *--> "0..*" "Variable"
  "Attribute" *--> "0..*" "Dimension"

  "Dimension" *--> "0..*" "Variable"
  
  "Variable" *--> "0..*" "Non-conformance"
  "Attribute" *--> "1..*" "Non-conformance"
  "Dimension" *--> "1..*" "Non-conformance"
}

@enduml

Examples to illustrate

Now the UGRID example case dataset_compliance output dict will look more like this:

{
    'pa': {
        'Conventions': '1.13',
        'attributes': {
            'standard_name': {
                'value': 'badname',
                'non-conformance': [{'code': 400022, 'reason': 'bad name'}]},
            'mesh': {
                'value': 'Mesh2'
                'variables' : {
                    'Mesh2': {
                        'attributes': {
                            'standard_name': {
                                'value': 'badname_Mesh2',
                                'non-conformance': [{'code': 400022, 'reason': 'bad name'}]},
                            'edge_node_connectivity': {
                                'variables': {
                                    'Mesh2_edge_nodes': {
                                        'attributes': {
                                            'standard_name': {
                                                'value': 'badname_Mesh2_edge_nodes',
                                                'non-conformance': [{'code': 400022, 'reason': 'bad name'}]}}}}},
                            'face_face_connectivity': {
                                'variables': {
                                    'Mesh2_face_links': {
                                        'attributes': {
                                            'standard_name': {
                                                'value': 'badname_Mesh2_face_links',
                                                'non-conformance': [{'code': 400022, 'reason': 'bad name'}]}}}}},
                            'face_node_connectivity': {
                                'variables': {
                                    'Mesh2_face_nodes': {
                                        'attributes': {
                                            'standard_name': {
                                                'value': 'badname_Mesh2_face_nodes',
                                                'non-conformance': [{'code': 400022, 'reason': 'bad name'}]}}}}}},
             'cell_methods': {
                 'value': 'area: moan wart area_types time1: anomaly_wrt norm',
                 'non-conformance': [{'code': 12345, 'reason': 'moan is not a valid method'},
                                     {'code': 67890, 'reason': 'wart is not a valid qualifier'}],
                 'variables': {
                     'norm': {'non-conformance': [{'code': 12345, 'reason': 'variable does not exist'}]},
                     'area_types': {
                         'attributes': {
                             'standard_name': {
                                 'value': 'badname',
                                 'non-conformance': [{'code': 400022, 'reason': 'bad name'}]}},
                         'dimensions': {'dim1': {
                             'size': 13,
                             'non-conformance': [{'code': 111167, 'reason': 'variable dimension has incompatible size'}]}}}},
                 'dimensions': {
                     'time1': {'non-conformance': [{'code': 265311, 'reason': 'dimension not a standard name nor associated with parent variable'}]}}}}}}
        },
        'dimensions': {
            'latitude':  {
                'size': 180,
                'variables': {
                    'latitude': {
                        'attributes':{
                            'standard_name': {
                                'value': 'badname_latitude',
                                'non-conformance': [{'code': 400022, 'reason': 'bad name'}]}}}}}}}
}