Skip to content

input4mips_validation.cvs.activity_id#

input4mips_validation.cvs.activity_id #

Activity ID CV handling

For validation, see validation.

ACTIVITY_ID_FILENAME: str = 'input4MIPs_activity_id.json' module-attribute #

Default name of the file in which the activity ID CV is saved

ActivityIDEntriesUnstructured: TypeAlias = dict[str, dict[str, str]] module-attribute #

Form into which activity ID entries are serialised for the CVs

ActivityIDEntries #

Helper container for handling activity ID entries

Source code in src/input4mips_validation/cvs/activity_id.py 
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
@define
class ActivityIDEntries:
    """
    Helper container for handling activity ID entries
    """

    entries: tuple[ActivityIDEntry, ...] = field()
    """Activity ID entries"""

    # Note: we are ok with the duplicate validation logic here,
    # because it makes implementation of our helper dunder methods
    # simpler if we can assume that the activity IDs are unique.
    @entries.validator
    def _entry_activity_ids_are_unique(
        self, attribute: attr.Attribute[Any], value: tuple[ActivityIDEntry, ...]
    ) -> None:
        activity_ids = self.activity_ids
        if len(activity_ids) != len(set(activity_ids)):
            raise NonUniqueError(
                description=(
                    "The activity_id's of the entries in `entries` are not unique"
                ),
                values=activity_ids,
            )

    def __getitem__(self, key: str) -> ActivityIDEntry:
        """
        Get [`ActivityIDEntry`][input4mips_validation.cvs.activity_id.ActivityIDEntry] by its name

        We return the [`ActivityIDEntry`][input4mips_validation.cvs.activity_id.ActivityIDEntry]
        whose activity_id matches `key`.
        """  # noqa: E501
        matching = [v for v in self.entries if v.activity_id == key]
        if not matching:
            msg = f"{key!r}. {self.activity_ids=!r}"
            raise KeyError(msg)

        if len(matching) > 1:  # pragma: no cover
            msg = (
                "`activity_id`'s should be validated as being unique at initialisation"
            )
            raise AssertionError(msg)

        return matching[0]

    def __iter__(self) -> Iterable[ActivityIDEntry]:
        """
        Iterate over `self.entries`
        """
        yield from self.entries

    def __len__(self) -> int:
        """
        Get length of `self.entries`
        """
        return len(self.entries)

    @property
    def activity_ids(self) -> tuple[str, ...]:
        """
        Activity IDs found in the list of entries

        Returns
        -------
            The `activity_id`'s found in the list of entries
        """
        return tuple(v.activity_id for v in self.entries)

activity_ids: tuple[str, ...] property #

Activity IDs found in the list of entries

Returns:

Type Description
The `activity_id`'s found in the list of entries

entries: tuple[ActivityIDEntry, ...] = field() class-attribute instance-attribute #

Activity ID entries

__getitem__(key) #

Get ActivityIDEntry by its name

We return the ActivityIDEntry whose activity_id matches key.

Source code in src/input4mips_validation/cvs/activity_id.py 
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
def __getitem__(self, key: str) -> ActivityIDEntry:
    """
    Get [`ActivityIDEntry`][input4mips_validation.cvs.activity_id.ActivityIDEntry] by its name

    We return the [`ActivityIDEntry`][input4mips_validation.cvs.activity_id.ActivityIDEntry]
    whose activity_id matches `key`.
    """  # noqa: E501
    matching = [v for v in self.entries if v.activity_id == key]
    if not matching:
        msg = f"{key!r}. {self.activity_ids=!r}"
        raise KeyError(msg)

    if len(matching) > 1:  # pragma: no cover
        msg = (
            "`activity_id`'s should be validated as being unique at initialisation"
        )
        raise AssertionError(msg)

    return matching[0]

__iter__() #

Iterate over self.entries

Source code in src/input4mips_validation/cvs/activity_id.py 
 99
100
101
102
103
def __iter__(self) -> Iterable[ActivityIDEntry]:
    """
    Iterate over `self.entries`
    """
    yield from self.entries

__len__() #

Get length of self.entries

Source code in src/input4mips_validation/cvs/activity_id.py 
105
106
107
108
109
def __len__(self) -> int:
    """
    Get length of `self.entries`
    """
    return len(self.entries)

ActivityIDEntry #

A single activity ID entry

Source code in src/input4mips_validation/cvs/activity_id.py 
41
42
43
44
45
46
47
48
49
50
51
@define
class ActivityIDEntry:
    """
    A single activity ID entry
    """

    activity_id: str
    """The unique value which identifies this activity ID"""

    values: ActivityIDValues
    """The values defined by this activity ID"""

activity_id: str instance-attribute #

The unique value which identifies this activity ID

values: ActivityIDValues instance-attribute #

The values defined by this activity ID

ActivityIDValues #

Values defined by an activity ID

Source code in src/input4mips_validation/cvs/activity_id.py 
28
29
30
31
32
33
34
35
36
37
38
@define
class ActivityIDValues:
    """
    Values defined by an activity ID
    """

    URL: str
    """URL where information about this activity can be found"""

    long_name: str
    """Long name/description of the activity"""

URL: str instance-attribute #

URL where information about this activity can be found

long_name: str instance-attribute #

Long name/description of the activity

convert_activity_id_entries_to_unstructured_cv(activity_id_entries) #

Convert a ActivityIDEntries to the raw CV form

Parameters:

Name Type Description Default
activity_id_entries ActivityIDEntries

Activity ID entries

 required

Returns:

Type Description
Raw CV data
Source code in src/input4mips_validation/cvs/activity_id.py 
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
def convert_activity_id_entries_to_unstructured_cv(
    activity_id_entries: ActivityIDEntries,
) -> ActivityIDEntriesUnstructured:
    """
    Convert a [`ActivityIDEntries`][input4mips_validation.cvs.activity_id.ActivityIDEntries] to the raw CV form

    Parameters
    ----------
    activity_id_entries
        Activity ID entries

    Returns
    -------
        Raw CV data
    """  # noqa: E501
    unstructured = converter_json.unstructure(activity_id_entries)

    raw_cv_form = {
        entry["activity_id"]: entry["values"] for entry in unstructured["entries"]
    }

    return raw_cv_form

convert_unstructured_cv_to_activity_id_entries(unstructured) #

Convert the raw CV data to a ActivityIDEntries

Parameters:

Name Type Description Default
unstructured ActivityIDEntriesUnstructured

Unstructured CV data

 required

Returns:

Type Description
Activity ID entries
Source code in src/input4mips_validation/cvs/activity_id.py 
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
def convert_unstructured_cv_to_activity_id_entries(
    unstructured: ActivityIDEntriesUnstructured,
) -> ActivityIDEntries:
    """
    Convert the raw CV data to a [`ActivityIDEntries`][input4mips_validation.cvs.activity_id.ActivityIDEntries]

    Parameters
    ----------
    unstructured
        Unstructured CV data

    Returns
    -------
        Activity ID entries
    """  # noqa: E501
    restructured = {
        "entries": [
            dict(activity_id=key, values=value) for key, value in unstructured.items()
        ]
    }

    return converter_json.structure(restructured, ActivityIDEntries)

load_activity_id_entries(raw_cvs_loader, filename=ACTIVITY_ID_FILENAME) #

Load the activity_id entries in the CVs

Parameters:

Name Type Description Default
raw_cvs_loader RawCVLoader

Loader of raw CVs data.

 required
filename str

Name of the file from which to load the CVs.

Passed to raw_cvs_loader.load_raw.

 ACTIVITY_ID_FILENAME

Returns:

Type Description
Loaded activity ID entries
Source code in src/input4mips_validation/cvs/activity_id.py 
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
def load_activity_id_entries(
    raw_cvs_loader: RawCVLoader,
    filename: str = ACTIVITY_ID_FILENAME,
) -> ActivityIDEntries:
    """
    Load the activity_id entries in the CVs

    Parameters
    ----------
    raw_cvs_loader
        Loader of raw CVs data.

    filename
        Name of the file from which to load the CVs.

        Passed to
        [`raw_cvs_loader.load_raw`][input4mips_validation.cvs.loading_raw.RawCVLoader.load_raw].

    Returns
    -------
        Loaded activity ID entries
    """
    return convert_unstructured_cv_to_activity_id_entries(
        json.loads(raw_cvs_loader.load_raw(filename=filename))
    )