14750979690

Committed 30 Apr 2025 09:10AM UTC coverage: 89.832% (+0.02%) from 89.81%

Build # 14750979690

Build Type

Pull #238

github

Committed by

web-flow

Commit Message

Merge 214c497cc into c00e6db3c

Pull Request Pull Request #238: Further sort candidate regions on lat lon in `Merger`

Run Details

8 of 8 new or added lines in 2 files covered. (100.0%)

3 existing lines in 1 file now uncovered.

2942 of 3275 relevant lines covered (89.83%)

3.31 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.85

/optim_esm_tools/plotting/plot.py

import typing as ty

import matplotlib.pyplot as plt
import xarray as xr

import optim_esm_tools as oet
from optim_esm_tools.config import config
from optim_esm_tools.config import get_logger


def setup_map(
    *a,
    projection: ty.Optional[str] = None,
    coastlines: bool = True,
    add_features: bool = False,
    add_gridlines: bool = True,
    coast_line_kw: ty.Optional[dict] = None,
    gridline_kw: ty.Optional[dict] = None,
    no_top_labels: bool = True,
    **projection_kwargs,
):
    plt.gcf().add_subplot(
        *a,
        projection=get_cartopy_projection(projection, **projection_kwargs),
    )
    ax = plt.gca()
    if coastlines:
        coast_line_kw = coast_line_kw or dict()
        ax.coastlines(**coast_line_kw)
    if add_features:
        import cartopy.feature as cfeature

        allowed = 'LAND OCEAN COASTLINE BORDERS LAKES RIVERS'.split()
        for feat in oet.utils.to_str_tuple(add_features):
            assert feat.upper() in allowed, f'{feat} not in {allowed}'
            ax.add_feature(getattr(cfeature, feat.upper()))
    if add_gridlines:
        gridline_kw = gridline_kw or dict(draw_labels=True)
        gl = ax.gridlines(**gridline_kw)
        if no_top_labels:
            gl.top_labels = False


def _show(show):
    if show:
        plt.show()  # pragma: no cover
    else:
        plt.clf()
        plt.close()


def default_variable_labels() -> ty.Dict[str, str]:
    labels = dict(config['variable_label'].items())
    ma = config['analyze']['moving_average_years']
    for k, v in list(labels.items()):
        labels[f'{k}_detrend'] = f'Detrend {v}'
        labels[f'{k}_run_mean_{ma}'] = f'$RM_{{{ma}}}$ {v}'
        labels[f'{k}_detrend_run_mean_{ma}'] = f'Detrend $RM_{{{ma}}}$ {v}'
    return labels


def get_range(var: str) -> ty.List[float]:
    r = (
        dict(oet.config.config['variable_range'].items())
        .get(var, 'None,None')
        .split(',')
    )
    return [(float(l) if l != 'None' else None) for l in r]


def set_y_lim_var(var: str) -> None:
    d, u = get_range(var)
    cd, cu = plt.ylim()
    plt.ylim(
        cd if d is None else min(cd, d),
        cu if u is None else max(cu, u),
    )


def get_unit_da(da: xr.DataArray) -> str:
    return da.attrs.get('units', '?').replace('%', r'\%')


def get_unit(ds: xr.Dataset, var: str) -> str:
    return get_unit_da(ds[var])


def get_cartopy_projection(
    projection: ty.Optional[ty.Any] = None,
    _field: str = 'projection',
    **projection_kwargs,
) -> ty.Any:
    import cartopy.crs as ccrs

    projection = projection or config['cartopy'][_field]
    if not hasattr(ccrs, projection):
        raise ValueError(f'Invalid projection {projection}')  # pragma: no cover
    return getattr(ccrs, projection)(**projection_kwargs)


def get_cartopy_transform(
    projection: ty.Optional[ty.Any] = None,
    **projection_kwargs,
) -> ty.Any:
    return get_cartopy_projection(
        projection=projection,
        _field='transform',
        **projection_kwargs,
    )


def get_xy_lim_for_projection(
    projection: ty.Optional[str] = None,
) -> ty.Tuple[ty.Tuple[float, float], ty.Tuple[float, float]]:
    """Blunt hardcoding for the different projections.

    Calling plt.xlim(0, 360) will have vastly different outcomes
    depending on the projection used. Here we hardcoded some of the more
    common.
    """
    projection = projection or config['cartopy']['projection']
    lims = dict(
        Robinson=(
            (-17005833.33052523, 17005833.33052523),
            (-8625154.6651, 8625154.6651),
        ),
        EqualEarth=(
            (-17243959.06221695, 17243959.06221695),
            (-8392927.59846645, 8392927.598466456),
        ),
        Mollweide=(
            (-18040095.696147293, 18040095.696147293),
            (-9020047.848073646, 9020047.848073646),
        ),
        PlateCarree=((0, 360), (-90, 90)),
    )
    if projection not in lims:
        get_logger().warning(
            f'No hardcoded x/y lims for {projection}, might yield odd figures.',
        )  # pragma: no cover
    return lims.get(projection, ((0, 360), (-90, 90)))


def plot_da(
    da: xr.DataArray,
    projection: ty.Optional[str] = None,
    setup_kw: ty.Optional[dict] = None,
    **kw,
):
    """Simple wrapper for da.plot() with correct transforms and projections."""
    setup_kw = setup_kw or dict()
    setup_map(projection=projection, **setup_kw)
    da.plot(transform=get_cartopy_transform(), **kw)


def get_ylabel(ds: xr.Dataset, var: ty.Optional[str] = None):
    var = var or ds.attrs.get('variable_id', 'var')
    return f'{oet.plotting.plot.default_variable_labels().get(var, var)} [{get_unit(ds, var)}]'

1	import typing as ty	4✔
2
3	import matplotlib.pyplot as plt	4✔
4	import xarray as xr	4✔
5
6	import optim_esm_tools as oet	4✔
7	from optim_esm_tools.config import config	4✔
8	from optim_esm_tools.config import get_logger	4✔
9
10
11	def setup_map(	4✔
12	*a,
13	projection: ty.Optional[str] = None,
14	coastlines: bool = True,
15	add_features: bool = False,
16	add_gridlines: bool = True,
17	coast_line_kw: ty.Optional[dict] = None,
18	gridline_kw: ty.Optional[dict] = None,
19	no_top_labels: bool = True,
20	**projection_kwargs,
21	):
22	plt.gcf().add_subplot(	4✔
23	*a,
24	projection=get_cartopy_projection(projection, **projection_kwargs),
25	)
26	ax = plt.gca()	4✔
27	if coastlines:	4✔
28	coast_line_kw = coast_line_kw or dict()	4✔
29	ax.coastlines(**coast_line_kw)	4✔
30	if add_features:	4✔
31	import cartopy.feature as cfeature	4✔
32
33	allowed = 'LAND OCEAN COASTLINE BORDERS LAKES RIVERS'.split()	4✔
34	for feat in oet.utils.to_str_tuple(add_features):	4✔
35	assert feat.upper() in allowed, f'{feat} not in {allowed}'	4✔
36	ax.add_feature(getattr(cfeature, feat.upper()))	4✔
37	if add_gridlines:	4✔
38	gridline_kw = gridline_kw or dict(draw_labels=True)	4✔
39	gl = ax.gridlines(**gridline_kw)	4✔
40	if no_top_labels:	4✔
41	gl.top_labels = False	4✔
42
43
44	def _show(show):	4✔
45	if show:	4✔
46	plt.show() # pragma: no cover
47	else:
48	plt.clf()	4✔
49	plt.close()	4✔
50
51
52	def default_variable_labels() -> ty.Dict[str, str]:	4✔
53	labels = dict(config['variable_label'].items())	4✔
54	ma = config['analyze']['moving_average_years']	4✔
55	for k, v in list(labels.items()):	4✔
56	labels[f'{k}_detrend'] = f'Detrend {v}'	4✔
57	labels[f'{k}_run_mean_{ma}'] = f'$RM_{{{ma}}}$ {v}'	4✔
58	labels[f'{k}_detrend_run_mean_{ma}'] = f'Detrend $RM_{{{ma}}}$ {v}'	4✔
59	return labels	4✔
60
61
62	def get_range(var: str) -> ty.List[float]:	4✔
63	r = (	4✔
64	dict(oet.config.config['variable_range'].items())
65	.get(var, 'None,None')
66	.split(',')
67	)
68	return [(float(l) if l != 'None' else None) for l in r]	4✔
69
70
71	def set_y_lim_var(var: str) -> None:	4✔
72	d, u = get_range(var)	4✔
73	cd, cu = plt.ylim()	4✔
74	plt.ylim(	4✔
75	cd if d is None else min(cd, d),
76	cu if u is None else max(cu, u),
77	)
78
79
80	def get_unit_da(da: xr.DataArray) -> str:	4✔
81	return da.attrs.get('units', '?').replace('%', r'\%')	4✔
82
83
84	def get_unit(ds: xr.Dataset, var: str) -> str:	4✔
85	return get_unit_da(ds[var])	4✔
86
87
88	def get_cartopy_projection(	4✔
89	projection: ty.Optional[ty.Any] = None,
90	_field: str = 'projection',
91	**projection_kwargs,
92	) -> ty.Any:
93	import cartopy.crs as ccrs	4✔
94
95	projection = projection or config['cartopy'][_field]	4✔
96	if not hasattr(ccrs, projection):	4✔
97	raise ValueError(f'Invalid projection {projection}') # pragma: no cover
98	return getattr(ccrs, projection)(**projection_kwargs)	4✔
99
100
101	def get_cartopy_transform(	4✔
102	projection: ty.Optional[ty.Any] = None,
103	**projection_kwargs,
104	) -> ty.Any:
105	return get_cartopy_projection(	4✔
106	projection=projection,
107	_field='transform',
108	**projection_kwargs,
109	)
110
111
112	def get_xy_lim_for_projection(	4✔
113	projection: ty.Optional[str] = None,
114	) -> ty.Tuple[ty.Tuple[float, float], ty.Tuple[float, float]]:
115	"""Blunt hardcoding for the different projections.
116
117	Calling plt.xlim(0, 360) will have vastly different outcomes
118	depending on the projection used. Here we hardcoded some of the more
119	common.
120	"""
UNCOV 121	projection = projection or config['cartopy']['projection']	×
122	lims = dict(	×
123	Robinson=(
124	(-17005833.33052523, 17005833.33052523),
125	(-8625154.6651, 8625154.6651),
126	),
127	EqualEarth=(
128	(-17243959.06221695, 17243959.06221695),
129	(-8392927.59846645, 8392927.598466456),
130	),
131	Mollweide=(
132	(-18040095.696147293, 18040095.696147293),
133	(-9020047.848073646, 9020047.848073646),
134	),
135	PlateCarree=((0, 360), (-90, 90)),
136	)
UNCOV 137	if projection not in lims:	×
138	get_logger().warning(
139	f'No hardcoded x/y lims for {projection}, might yield odd figures.',
140	) # pragma: no cover
UNCOV 141	return lims.get(projection, ((0, 360), (-90, 90)))	×
142
143
144	def plot_da(	4✔
145	da: xr.DataArray,
146	projection: ty.Optional[str] = None,
147	setup_kw: ty.Optional[dict] = None,
148	**kw,
149	):
150	"""Simple wrapper for da.plot() with correct transforms and projections."""
151	setup_kw = setup_kw or dict()	4✔
152	setup_map(projection=projection, **setup_kw)	4✔
153	da.plot(transform=get_cartopy_transform(), **kw)	4✔
154
155
156	def get_ylabel(ds: xr.Dataset, var: ty.Optional[str] = None):	4✔
157	var = var or ds.attrs.get('variable_id', 'var')	4✔
158	return f'{oet.plotting.plot.default_variable_labels().get(var, var)} [{get_unit(ds, var)}]'	4✔

JoranAngevaare / optim_esm_tools / 14750979690

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous