satpy.dataset.dataid module

Dataset identifying objects.

class satpy.dataset.dataid.DataID(id_keys, **keyval_dict)

Bases: dict

Identifier for all DataArray objects.

DataID is a dict that holds identifying and classifying information about a DataArray.

Init the DataID.

The id_keys dictionary has to be formed as described in Satpy internal workings: having a look under the hood. The other keyword arguments are values to be assigned to the keys. Note that None isn’t a valid value and will simply be ignored.

_asdict()

_find_modifiers_key()

_immutable(*args, **kws) → NoReturn

Raise and error.

_replace(**kwargs)

Make a new instance with replaced items.

classmethod _unpickle(id_keys, keyval)

Create a new instance of the DataID after pickling.

clear(*args, **kws) → NoReturn

Raise and error.

convert_dict(keyvals)

Convert a dictionary’s values to the types defined in this object’s id_keys.

create_filter_query_without_required_fields(query)

Remove the required fields from query.

create_less_modified_query()

Create a query with one less modifier.

static fix_id_keys(id_keys)

Flesh out enums in the id keys as gotten from a config.

classmethod from_dataarray(array, default_keys={'name': {'required': True}, 'resolution': {'transitive': True}})

Get the DataID using the dataarray attributes.

from_dict(keyvals)

Create a DataID from a dictionary.

property id_keys

Get the id_keys.

is_modified()

Check if this is modified.

classmethod new_id_from_dataarray(array, default_keys={'name': {'required': True}, 'resolution': {'transitive': True}})

Create a new DataID from a dataarray’s attributes.

pop(*args, **kws) → NoReturn

Raise and error.

popitem(*args, **kws) → NoReturn

Raise and error.

setdefault(*args, **kws) → NoReturn

Raise and error.

to_dict()

Convert the ID to a dict.

update(*args, **kws) → NoReturn

Raise and error.

class satpy.dataset.dataid.DataQuery(**kwargs)

Bases: object

The data query object.

A DataQuery can be used in Satpy to query for a Dataset. This way a fully qualified DataID can be found even if some DataID elements are unknown. In this case a * signifies something that is unknown or not applicable to the requested Dataset.

Initialize the query.

static _add_absolute_distance(dataid, key, distance)

static _add_distance_from_query(dataid_val, requested_val, distance)

_asdict()

_match_dataid(dataid)

Match the dataid with the current query.

_match_query_value(key, id_val)

_shares_required_keys(dataid)

Check if dataid shares required keys with the current query.

_to_trimmed_dict()

create_less_modified_query()

Create a query with one less modifier.

filter_dataids(dataid_container)

Filter DataIDs based on this query.

classmethod from_dict(the_dict)

Convert a dict to an ID.

get(key, default=None)

Get an item.

is_modified()

Check if this is modified.

items()

Get the items of this query.

sort_dataids(dataids)

Sort the DataIDs based on this query.

Returns the sorted dataids and the list of distances.

The sorting is performed based on the types of the keys to search on (as they are defined in the DataIDs from dataids). If that type defines a distance method, then it is used to find how ‘far’ the DataID is from the current query. If the type is a number, a simple subtraction is performed. For other types, the distance is 0 if the values are identical, np.inf otherwise.

For example, with the default DataID, we use the following criteria:

1. Central wavelength is nearest to the key wavelength if specified.

2. Least modified dataset if modifiers is None in key. Otherwise, the modifiers are ignored.

3. Highest calibration if calibration is None in key. Calibration priority is the order of the calibration list defined as reflectance, brightness temperature, radiance counts if not overridden in the reader configuration.

4. Best resolution (smallest number) if resolution is None in key. Otherwise, the resolution is ignored.

sort_dataids_with_preference(all_ids, preference)

Sort all_ids given a sorting preference (DataQuery or None).

to_dict(trim=True)

Convert the ID to a dict.

class satpy.dataset.dataid.ModifierTuple(iterable=(), /)

Bases: tuple

A tuple holder for modifiers.

classmethod convert(modifiers)

Convert modifiers to this type if possible.

class satpy.dataset.dataid.ValueList(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: IntEnum

A static value list.

This class is meant to be used for dynamically created Enums. Due to this it should not be used as a normal Enum class or there may be some unexpected behavior. For example, this class contains custom pickling and unpickling handling that may break in subclasses.

classmethod _unpickle(enum_name, enum_members, enum_member)

Create dynamic class that was previously pickled.

See __reduce_ex__() for implementation details.

classmethod convert(value)

Convert value to an instance of this class.

class satpy.dataset.dataid.WavelengthRange(min, central, max, unit='µm')

Bases: WavelengthRange

A named tuple for wavelength ranges.

The elements of the range are min, central and max values, and optionally a unit (defaults to µm). No clever unit conversion is done here, it’s just used for checking that two ranges are comparable.

Create new instance of WavelengthRange(min, central, max, unit)

classmethod _read_cf_from_string_export(blob)

Read blob as a string created by to_cf.

classmethod _read_cf_from_string_list(blob)

Read blob as a list of strings (legacy formatting).

classmethod convert(wl)

Convert wl to this type if possible.

distance(value)

Get the distance from value.

classmethod from_cf(blob)

Return a WavelengthRange from a cf blob.

to_cf()

Serialize for cf export.

satpy.dataset.dataid._create_id_dict_from_any_key(dataset_key)

satpy.dataset.dataid._generalize_value_for_comparison(val)

Get a generalize value for comparisons.

satpy.dataset.dataid._update_dict_with_filter_query(ds_dict, filter_query)

satpy.dataset.dataid.create_filtered_query(dataset_key, filter_query)

Create a DataQuery matching dataset_key and filter_query.

If a property is specified in both dataset_key and filter_query, the former has priority.

satpy.dataset.dataid.default_co_keys_config = {'name': {'required': True}, 'resolution': {'transitive': True}}

Default ID keys for coordinate DataArrays.

satpy.dataset.dataid.default_id_keys_config = {'calibration': {'enum': ['reflectance', 'brightness_temperature', 'radiance', 'radiance_wavenumber', 'counts'], 'transitive': True}, 'modifiers': {'default': (), 'type': <class 'satpy.dataset.dataid.ModifierTuple'>}, 'name': {'required': True}, 'resolution': {'transitive': False}, 'wavelength': {'type': <class 'satpy.dataset.dataid.WavelengthRange'>}}

Default ID keys DataArrays.

satpy.dataset.dataid.get_keys_from_config(common_id_keys, config)

Gather keys for a new DataID from the ones available in configured dataset.

satpy.dataset.dataid.minimal_default_keys_config = {'name': {'required': True}, 'resolution': {'transitive': True}}

Minimal ID keys for DataArrays, for example composites.

satpy.dataset.dataid.wlklass

alias of WavelengthRange