src.data_model module

Classes to describe “abstract” properties of model data: aspects that are independent of any model, experiment, or hosting protocol.

class src.data_model.AbstractDMCoordinate

Bases: abc.ABC

Defines interface (set of attributes) for DMCoordinate objects.

abstract property name

abstract property standard_name

abstract property units

abstract property axis

abstract property bounds

abstract property value

abstract property is_scalar

abstract property has_bounds

_abc_impl = <_abc_data object>

class src.data_model.AbstractDMDependentVariable

Bases: abc.ABC

Defines interface (set of attributes) for “dependent variables” (data defined as a function of one or more dimension coordinates), which inherit from DMDimensions in this implementation.

abstract property name

abstract property standard_name

abstract property units

abstract property dims

abstract property scalar_coords

abstract property axes

abstract property all_axes

abstract property X

abstract property Y

abstract property Z

abstract property T

abstract property is_static

_abc_impl = <_abc_data object>

class src.data_model.AbstractDMCoordinateBounds

Bases: src.data_model.AbstractDMDependentVariable

Defines interface (set of attributes) for DMCoordinateBounds objects.

abstract property coord

_abc_impl = <_abc_data object>

class src.data_model.DMBoundsDimension(name: str = sentinel.Mandatory)

Bases: object

Placeholder object to represent the bounds dimension of a DMCoordinateBounds object. Not a dimension coordinate, and strictly speaking we should make another set of classes for dimensions.

name: str = sentinel.Mandatory

standard_name = 'bounds'

axis = 'BOUNDS'

bounds = None

value = None

property has_bounds

property is_scalar

class src.data_model._DMCoordinateShared(standard_name: str = sentinel.Mandatory, units: src.units.Units = sentinel.Mandatory, axis: str = 'OTHER', bounds_var: src.data_model.AbstractDMCoordinateBounds = None, value: Union[int, float] = None)

Bases: object

Fields common to all AbstractDMCoordinate child classes which aren’t fixed to particular values.

value is our mechanism for implementing CF convention scalar coordinates.

standard_name: str = sentinel.Mandatory

units: src.units.Units = sentinel.Mandatory

axis: str = 'OTHER'

bounds_var: src.data_model.AbstractDMCoordinateBounds = None

value: Union[int, float] = None

property bounds

Store bounds_var as a pointer to the actual object representing the bounds variable for this coordinate, but in order to parallel xarray’s syntax define ‘bounds’ to return the name of this variable, not the variable itself.

property has_bounds

property is_scalar

make_scalar(new_value)

class src.data_model.DMCoordinate(standard_name: str = sentinel.Mandatory, units: src.units.Units = sentinel.Mandatory, axis: str = 'OTHER', bounds_var: src.data_model.AbstractDMCoordinateBounds = None, value: Union[int, float] = None, name: str = sentinel.Mandatory)

Bases: src.data_model._DMCoordinateShared

Class to describe a single coordinate variable (in the sense used by the CF conventions).

name: str = sentinel.Mandatory

standard_name: str = sentinel.Mandatory

units: src.units.Units = sentinel.Mandatory

axis: str = 'OTHER'

class src.data_model.DMLongitudeCoordinate(standard_name: str = 'longitude', units: src.units.Units = 'degrees_east', axis: str = 'X', bounds_var: src.data_model.AbstractDMCoordinateBounds = None, value: Union[int, float] = None, name: str = 'lon')

Bases: src.data_model._DMCoordinateShared

name: str = 'lon'

standard_name: str = 'longitude'

units: src.units.Units = 'degrees_east'

axis: str = 'X'

class src.data_model.DMLatitudeCoordinate(standard_name: str = 'latitude', units: src.units.Units = 'degrees_north', axis: str = 'Y', bounds_var: src.data_model.AbstractDMCoordinateBounds = None, value: Union[int, float] = None, name: str = 'lat')

Bases: src.data_model._DMCoordinateShared

name: str = 'lat'

standard_name: str = 'latitude'

units: src.units.Units = 'degrees_north'

axis: str = 'Y'

class src.data_model.DMVerticalCoordinate(standard_name: str = sentinel.Mandatory, units: src.units.Units = '1', axis: str = 'Z', bounds_var: src.data_model.AbstractDMCoordinateBounds = None, value: Union[int, float] = None, name: str = sentinel.Mandatory, positive: str = sentinel.Mandatory)

Bases: src.data_model._DMCoordinateShared

Class to describe a non-parametric vertical coordinate (height or depth), following the CF conventions.

name: str = sentinel.Mandatory

standard_name: str = sentinel.Mandatory

units: src.units.Units = '1'

axis: str = 'Z'

positive: str = sentinel.Mandatory

class src.data_model.DMParametricVerticalCoordinate(standard_name: str = sentinel.Mandatory, units: src.units.Units = '1', axis: str = 'Z', bounds_var: src.data_model.AbstractDMCoordinateBounds = None, value: Union[int, float] = None, name: str = sentinel.Mandatory, positive: str = sentinel.Mandatory, computed_standard_name: str = '', long_name: str = '', formula_terms: str = None)

Bases: src.data_model.DMVerticalCoordinate

Class to describe parametric vertical coordinates. Note that the variable names appearing in formula_terms aren’t parsed here, in order to keep the class hashable.

computed_standard_name: str = ''

long_name: str = ''

formula_terms: str = None

class src.data_model.DMGenericTimeCoordinate(standard_name: str = 'time', units: src.units.Units = '', axis: str = 'T', bounds_var: src.data_model.AbstractDMCoordinateBounds = None, value: Union[int, float] = None, name: str = 'time', calendar: str = '', range: Any = None)

Bases: src.data_model._DMCoordinateShared

Applies to collections of variables, which may be at different frequencies (or other attributes).

name: str = 'time'

standard_name: str = 'time'

units: src.units.Units = ''

axis: str = 'T'

calendar: str = ''

range: Any = None

property is_static

Check for time-independent data (‘fx’ in CMIP6 DRS.) Do the comparison by checking date_range against the placeholder value because that’s unique – we may be using a different DateFrequency depending on the data source.

classmethod from_instances(*t_coords)

Create new instance from “union” of attributes of t_coords.

class src.data_model.DMTimeCoordinate(standard_name: str = 'time', units: src.units.Units = sentinel.Mandatory, axis: str = 'T', bounds_var: src.data_model.AbstractDMCoordinateBounds = None, value: Union[int, float] = None, name: str = sentinel.Mandatory, calendar: str = '', range: src.util.datelabel.AbstractDateRange = None, frequency: src.util.datelabel.AbstractDateFrequency = None)

Bases: src.data_model.DMGenericTimeCoordinate

name: str = sentinel.Mandatory

standard_name: str = 'time'

units: src.units.Units = sentinel.Mandatory

axis: str = 'T'

calendar: str = ''

range: src.util.datelabel.AbstractDateRange = None

frequency: src.util.datelabel.AbstractDateFrequency = None

classmethod from_instances(*t_coords)

Create new instance from “union” of attributes of t_coords.

src.data_model.coordinate_from_struct(d, class_dict=None, **kwargs)

Attempt to instantiate the correct DMCoordinate class based on information in d.

TODO: implement full cf_xarray/MetPy heuristics.

class src.data_model._DMPlaceholderCoordinateBase

Bases: object

Dummy base class for placeholder coordinates. Placeholder coordinates are only used in instantiating FieldlistEntry objects: they’re replaced by the appropriate translated coordinates when that object is used to create a TranslatedVarlistEntry object.

class src.data_model.DMPlaceholderCoordinate(standard_name: str = NotImplemented, units: src.units.Units = NotImplemented, axis: str = 'OTHER', bounds_var: src.data_model.AbstractDMCoordinateBounds = None, value: Union[int, float] = None, name: str = 'PLACEHOLDER_COORD')

Bases: src.data_model._DMCoordinateShared, src.data_model._DMPlaceholderCoordinateBase

name: str = 'PLACEHOLDER_COORD'

standard_name: str = NotImplemented

units: src.units.Units = NotImplemented

axis: str = 'OTHER'

class src.data_model.DMPlaceholderXCoordinate(standard_name: str = NotImplemented, units: src.units.Units = NotImplemented, axis: str = 'X', bounds_var: src.data_model.AbstractDMCoordinateBounds = None, value: Union[int, float] = None, name: str = 'PLACEHOLDER_X_COORD')

Bases: src.data_model._DMCoordinateShared, src.data_model._DMPlaceholderCoordinateBase

name: str = 'PLACEHOLDER_X_COORD'

standard_name: str = NotImplemented

units: src.units.Units = NotImplemented

axis: str = 'X'

class src.data_model.DMPlaceholderYCoordinate(standard_name: str = NotImplemented, units: src.units.Units = NotImplemented, axis: str = 'Y', bounds_var: src.data_model.AbstractDMCoordinateBounds = None, value: Union[int, float] = None, name: str = 'PLACEHOLDER_Y_COORD')

Bases: src.data_model._DMCoordinateShared, src.data_model._DMPlaceholderCoordinateBase

name: str = 'PLACEHOLDER_Y_COORD'

standard_name: str = NotImplemented

units: src.units.Units = NotImplemented

axis: str = 'Y'

class src.data_model.DMPlaceholderZCoordinate(standard_name: str = NotImplemented, units: src.units.Units = NotImplemented, axis: str = 'Z', bounds_var: src.data_model.AbstractDMCoordinateBounds = None, value: Union[int, float] = None, name: str = 'PLACEHOLDER_Z_COORD', positive: str = NotImplemented)

Bases: src.data_model._DMCoordinateShared, src.data_model._DMPlaceholderCoordinateBase

name: str = 'PLACEHOLDER_Z_COORD'

standard_name: str = NotImplemented

units: src.units.Units = NotImplemented

axis: str = 'Z'

positive: str = NotImplemented

class src.data_model.DMPlaceholderTCoordinate(standard_name: str = NotImplemented, units: src.units.Units = NotImplemented, axis: str = 'T', bounds_var: src.data_model.AbstractDMCoordinateBounds = None, value: Union[int, float] = None, name: str = 'PLACEHOLDER_T_COORD', calendar: str = NotImplemented, range: Any = None)

Bases: src.data_model._DMCoordinateShared, src.data_model._DMPlaceholderCoordinateBase

name: str = 'PLACEHOLDER_T_COORD'

standard_name: str = NotImplemented

units: src.units.Units = NotImplemented

axis: str = 'T'

calendar: str = NotImplemented

range: Any = None

property is_static

Check for time-independent data (‘fx’ in CMIP6 DRS.) Do the comparison by checking date_range against the placeholder value because that’s unique – we may be using a different DateFrequency depending on the data source.

class src.data_model._DMDimensionsMixin(coords: dataclasses.InitVar = None)

Bases: object

Lookups for the dimensions, and associated dimension coordinates, associated with an array (eg a variable or auxiliary coordinate.) Needs to be included as a parent class of a dataclass.

coords: dataclasses.InitVar = None

dims: list

scalar_coords: list

property dim_axes

property X

property Y

property Z

property T

property dim_axes_set

property is_static

get_scalar(ax_name)

If the axis label ax_name is a scalar coordinate, return the corresponding AbstractDMCoordinate object, otherwise return None.

build_axes(*coords, verify=True)

Constructs a dict mapping axes labels to dimension coordinates (of type AbstractDMCoordinate.)

change_coord(ax_name, new_class=None, **kwargs)

Replace attributes on a given coordinate, but also optionally cast them to new classes. Kind of hacky.

class src.data_model.DMDependentVariable(coords: dataclasses.InitVar = None, name: str = sentinel.Mandatory, standard_name: str = sentinel.Mandatory, units: src.units.Units = '')

Bases: src.data_model._DMDimensionsMixin

Base class for any “dependent variable”: all non-dimension-coordinate information that depends on one or more dimension coordinates.

name: str = sentinel.Mandatory

standard_name: str = sentinel.Mandatory

units: src.units.Units = ''

property full_name

property axes

Superset of the .dim_axes dict (whose values contain coordinate dimensions only) that includes axes corresponding to scalar coordinates.

property axes_set

Superset of the .dim_axes_set frozenset (which contains axes labels corresponding to coordinate dimensions only) that includes axes labels corresponding to scalar coordinates.

add_scalar(ax, ax_value, **kwargs)

Metadata operation corresponding to taking a slice of a higher-dimensional variable (extracting its values at axis ax = ax_value). The coordinate corresponding to ax is removed from the list of coordinate dimensions and added to the list of scalar coordinates.

remove_scalar(ax, position=- 1, **kwargs)

Metadata operation that’s the inverse of add_scalar(). Given an axis label ax that’s currently a scalar coordinate, remove the slice value and add it to the list of dimension coordinates at position (default end of the list.)

class src.data_model.DMAuxiliaryCoordinate(coords: dataclasses.InitVar = None, name: str = sentinel.Mandatory, standard_name: str = sentinel.Mandatory, units: src.units.Units = '')

Bases: src.data_model.DMDependentVariable

Class to describe auxiliary coordinate variables, as defined in the CF conventions. An example would be lat or lon for data presented in a tripolar grid projection.

class src.data_model.DMCoordinateBounds(coords: dataclasses.InitVar = None, name: str = sentinel.Mandatory, standard_name: str = sentinel.Mandatory, units: src.units.Units = '')

Bases: src.data_model.DMAuxiliaryCoordinate

Class describing bounds on a dimension coordinate.

property coord

CF dimension coordinate for which this is the bounds.

classmethod from_coordinate(coord, bounds_dim)

class src.data_model.DMVariable(coords: dataclasses.InitVar = None, name: str = sentinel.Mandatory, standard_name: str = sentinel.Mandatory, units: src.units.Units = '')

Bases: src.data_model.DMDependentVariable

Class to describe general properties of data variables.

class src.data_model.DMDataSet(coords: dataclasses.InitVar = None, contents: dataclasses.InitVar = sentinel.Mandatory)

Bases: src.data_model._DMDimensionsMixin

Class to describe a collection of one or more variables sharing a set of common dimensions.

contents: dataclasses.InitVar = sentinel.Mandatory

vars: list

coord_bounds: list

aux_coords: list

iter_contents()

Generator iterating over the full contents of the DataSet (variables, auxiliary coordinates and coordinate bounds.)

iter_vars()

Generator iterating over variables and auxiliary coordinates but excluding coordinate bounds.

_classify(v)

add_contents(*vars_)

change_coord(ax_name, new_class=None, **kwargs)

Replace attributes on a given coordinate, but also optionally cast them to new classes. Kind of hacky.