940225349

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/oemof/feedinlib/commit/<a class=hub.com/oemof/feedinlib/commit/<a class="double-link" href="https://git"><a class=hub.com/oemof/feedinlib/commit/<a class="double-link" href="https://git"><a class=hub.com/oemof/feedinlib/commit/6665f4a11005853f680645a2f6fbdaf85871cd85">6665f4a11<a href="https://github.com/oemof/feedinlib/commit/6665f4a11005853f680645a2f6fbdaf85871cd85">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/oemof/feedinlib/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/oemof/feedinlib/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/oemof/feedinlib/commit/6665f4a11005853f680645a2f6fbdaf85871cd85&quot;&gt;6665f4a11&lt;/a&gt;&lt;a href=&quot;https://github.com/oemof/feedinlib/commit/6665f4a11005853f680645a2f6fbdaf85871cd85&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/oemof/feedinlib/commit/6665f4a11005853f680645a2f6fbdaf8&lt;/a&gt;5871cd85">&quot;&gt;Merge &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/oemof/feedinlib/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/oemof/feedinlib/commit/<a class="double-link" href="https://github.com/oemof/feedinlib/commit/88c89e674fb4a4257f50f81ab7601edb7d3b9392">88c89e674</a><a href="https://github.com/oemof/feedinlib/commit/6665f4a11005853f680645a2f6fbdaf85871cd85">&amp;quot;&amp;gt;88c89e674&amp;lt;/a&amp;gt;&amp;quot;&amp;gt;88c89e674&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/oemof/feedinlib/commit/6665f4a11005853f680645a2f6fbdaf85871c&lt;/a&gt;d85&quot;&gt; into &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/oemof/feedinlib/commit/<a class="double-link" href="https://github.com/oemof/feedinlib/commit/f5ef50e84">f5ef50e84">f5ef50e84</a>

Pull Request Pull Request #58: Revise the feedinlib structure following the structure of the other oemof packages

Run Details

102 of 273 branches covered (37.36%)

Branch coverage included in aggregate %.

122 of 122 new or added lines in 12 files covered. (100.0%)

584 of 869 relevant lines covered (67.2%)

1.34 hits per line

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

11.86

/src/feedinlib/cds_request_tools.py

import logging
import os
from datetime import datetime
from datetime import timedelta
from tempfile import mkstemp

import cdsapi
import numpy as np
import xarray as xr

logger = logging.getLogger(__name__)


def _get_cds_data(
    dataset_name="reanalysis-era5-single-levels",
    target_file=None,
    chunks=None,
    cds_client=None,
    **cds_params,
):
    """
    Download data from the Climate Data Store (CDS)

    Requirements:
    * user account at https://cds.climate.copernicus.eu to use this function
    * cdsapi package installed (https://cds.climate.copernicus.eu/api-how-to)

    :param dataset_name: (str) short name of the dataset of the CDS. To find
        it, click on a dataset found in
        https://cds.climate.copernicus.eu/cdsapp#!/search?type=dataset and go
        to the 'Download data' tab, then scroll down the page and click on
        'Show API request', the short name is the string on the 6th line
        after 'c.retrieve('
    :param target_file: (str) name of the file to save downloaded locally
    :param chunks: (dict)
    :param cds_client: handle to CDS client (if none is provided, then it is
        created)
    :param cds_params: (dict) parameter to pass to the CDS request

    :return: CDS data in an xarray format

    """

    # https://cds.climate.copernicus.eu/api-how-to
    if cds_client is None:
        cds_client = cdsapi.Client()

    # Default request
    request = {
        "format": "netcdf",
        "product_type": "reanalysis",
        "time": [
            "00:00",
            "01:00",
            "02:00",
            "03:00",
            "04:00",
            "05:00",
            "06:00",
            "07:00",
            "08:00",
            "09:00",
            "10:00",
            "11:00",
            "12:00",
            "13:00",
            "14:00",
            "15:00",
            "16:00",
            "17:00",
            "18:00",
            "19:00",
            "20:00",
            "21:00",
            "22:00",
            "23:00",
        ],
    }

    # Add user provided cds parameters to the request dict
    request.update(cds_params)

    assert {"year", "month", "variable"}.issubset(
        request
    ), "Need to specify at least 'variable', 'year' and 'month'"

    # Send the data request to the server
    result = cds_client.retrieve(dataset_name, request)

    no_target_file_provided = target_file is None
    # Create a file in a secure way if a target filename was not provided
    if no_target_file_provided is True:
        fd, target_file = mkstemp(suffix=".nc")
        os.close(fd)

    logger.info(
        "Downloading request for {} variables to {}".format(
            len(request["variable"]), target_file
        )
    )

    # Download the data in the target file
    result.download(target_file)

    # Extract the data from the target file
    answer = xr.open_dataset(target_file, chunks=chunks)

    # Now that the data has been extracted the file path is removed if it was
    # not provided. This will currently not work on windows if the dataset is
    # too large as the file will be locked by the reading process.
    if no_target_file_provided is True:
        os.unlink(target_file)

    # Here yield might be preferable in case of large datasets
    return answer


def _format_cds_request_datespan(start_date, end_date):
    """
    Format the dates between two given dates in order to submit a CDS request

    :param start_date: (str) start date of the range in YYYY-MM-DD format
    :param end_date: (str) end date of the range in YYYY-MM-DD format

    :return: a dict with the years, months and days of all the dates as lists
        of string

    """

    answer = {"year": [], "month": [], "day": []}
    fmt = "%Y-%m-%d"
    specific_fmt = {"year": "%4d", "month": "%02d", "day": "%02d"}
    start_dt = datetime.strptime(start_date, fmt)
    end_dt = datetime.strptime(end_date, fmt)

    if end_dt < start_dt:
        logger.warning(
            "Swapping input dates as the end date '{}' is prior to the "
            "start date '{}'.".format(end_date, start_date)
        )
        start_dt = end_dt
        end_dt = datetime.strptime(start_date, fmt)

    for n in range(int((end_dt - start_dt).days) + 1):
        cur_dt = start_dt + timedelta(n)

        # Add string value of the date's year, month and day to the
        # corresponding lists in the dict which will be returned
        for key, val in zip(
            ["year", "month", "day"], [cur_dt.year, cur_dt.month, cur_dt.day]
        ):
            val = specific_fmt[key] % val
            if val not in answer[key]:
                answer[key].append(val)

    # If the datespan is over more than a month, then all days are filled and
    # the entire months are returned (for CDS request the days format for a
    # full month is 31 days).
    if len(answer["month"]) > 1:
        answer["day"] = [str(d) for d in range(1, 32, 1)]

    return answer


def _format_cds_request_area(
    latitude_span=None, longitude_span=None, grid=None
):
    """
    Format the area between two given latitude and longitude spans in order
    to submit a CDS request

    The grid convention of the era5 HRES is used with a native resolution of
    0.28125 deg. For NetCDF format, the data is interpolated to a regular
    lat/lon grid with 0.25 deg resolution.
    In this grid the earth is modelled by a sphere with radius
    R_E = 6367.47 km. Latitude values in the range [-90, 90] relative to the
    equator and longitude values in the range [-180, 180]
    relative to the Greenwich Prime Meridian [1].

    References:
    [1] https://confluence.ecmwf.int/display/CKB/ERA5%3A+What+is+the+spatial+reference
    [2] https://confluence.ecmwf.int/display/UDOC/Post-processing+keywords

    :param latitude_span: (list of float) formatted as [N,S]. The span is
        between North and South latitudes (relative to the equator). North
        corresponds to positive latitude [2].
    :param longitude_span: (list of float) formatted as [W,E]. The span is
        between East and West longitudes (relative to the Greenwich meridian).
        East corresponds to positive longitude [2].
    :param grid: (list of float) provide the latitude and longitude grid
        resolutions in deg. It needs to be an integer fraction of 90 deg [2].

    :return: a dict containing the grid and, if `latitude_span` and/or
        `longitude_span` were specified, the area formatted for a CDS request

    """  # noqa: E501

    answer = {}

    # Default value of the grid
    if grid is None:
        grid = [0.25, 0.25]

    if latitude_span is not None and longitude_span is not None:
        area = [
            latitude_span[0],
            longitude_span[0],
            latitude_span[1],
            longitude_span[1],
        ]
    elif latitude_span is None and longitude_span is not None:
        area = [90, longitude_span[0], -90, latitude_span[1]]
    elif latitude_span is not None and longitude_span is None:
        area = [latitude_span[0], -180, latitude_span[1], 180]
    else:
        area = []

    # Format the 'grid' keyword of the CDS request as
    # lat_resolution/lon_resolution
    answer["grid"] = "%.2f/%.2f" % (grid[0], grid[1])

    # Format the 'area' keyword of the CDS request as N/W/S/E
    if area:
        answer["area"] = "/".join(str(e) for e in area)

    return answer


def _format_cds_request_position(latitude, longitude, grid=None):
    """
    Reduce the area of a CDS request to a single GIS point on the earth grid

    Find the closest grid point for the given longitude and latitude.

    The grid convention of the era5 HRES is used here with a native
    resolution of 0.28125 deg. For NetCDF format the data is interpolated to a
    regular lat/lon grid with 0.25 deg resolution. In this grid the earth is
    modelled by a sphere with radius R_E = 6367.47 km. latitude values
    in the range [-90, 90] relative to the equator and longitude values in the
    range [-180, 180] relative to the Greenwich Prime Meridian [1].

    References:
    [1] https://confluence.ecmwf.int/display/CKB/ERA5%3A+What+is+the+spatial+reference
    [2] https://confluence.ecmwf.int/display/UDOC/Post-processing+keywords

    :param latitude: (number) latitude in the range [-90, 90] relative to the
        equator, north correspond to positive latitude.
    :param longitude: (number) longitude in the range [-180, 180] relative to
        Greenwich Meridian, east relative to the meridian correspond to
        positive longitude.
    :param grid: (list of float) provide the latitude and longitude grid
        resolutions in deg. It needs to be an integer fraction of 90 deg [2].

    :return: a dict containing the grid and the area formatted for a CDS
        request

    """  # noqa: E501

    # Default value of the grid
    if grid is None:
        grid = [0.25, 0.25]

    # Find the nearest point on the grid corresponding to the given latitude
    # and longitude
    grid_point = xr.Dataset(
        {
            "lat": np.arange(90, -90, -grid[0]),
            "lon": np.arange(-180, 180.0, grid[1]),
        }
    ).sel(lat=latitude, lon=longitude, method="nearest")

    # Prepare an area which consists of only one grid point
    lat, lon = [float(grid_point.coords[s]) for s in ("lat", "lon")]
    return _format_cds_request_area(
        latitude_span=[lat, lat], longitude_span=[lon, lon], grid=grid
    )


def get_cds_data_from_datespan_and_position(
    start_date,
    end_date,
    latitude=None,
    longitude=None,
    grid=None,
    **cds_params,
):
    """
    Format request for data from the Climate Data Store (CDS)

    prepare a CDS request from user specified date span for a single grid point
    closest to the specified latitude and longitude.

    see _get_cds_data() for prior requirements and more information

    :param start_date: (str) start date of the datespan in YYYY-MM-DD format
    :param end_date: (str) end date of the datespan in YYYY-MM-DD format
    :param latitude: (number or list of float or None)
        * number: latitude in the range [-90, 90] relative to the
        equator, north correspond to positive latitude.
        * list of float: must be formatted as [N,S]. The span is
        between North and South latitudes (relative to the equator). North
        corresponds to positive latitude.
        * None: No geographical subset is selected.
    :param longitude: (number or list of float or None)
        * number: longitude in the range [-180, 180] relative to
        Greenwich Meridian, east relative to the meridian correspond to
        positive longitude.
        * list of float: must be formatted as [W,E]. The span is
        between East and West longitudes (relative to the Greenwich meridian).
        East corresponds to positive longitude
        * None: No geographical subset is selected.
    :param grid: (list of float) provide the latitude and longitude grid
        resolutions in deg. It needs to be an integer fraction of 90 deg.
    :param dataset_name: (str) short name of the dataset of the CDS. To find
        it, click on a dataset found in
        https://cds.climate.copernicus.eu/cdsapp#!/search?type=dataset and go
        to the 'Download data' tab, then scroll down the page and click on
        'Show API request', the short name is the string on the 6th line
        after 'c.retrieve('
    :param target_file: (str) name of the file in which downloading the data
        locally
    :param chunks: (dict)
    :param cds_client: handle to CDS client (if none is provided, then it is
        created)
    :param cds_params: (dict) parameter to pass to the CDS request

    :return: CDS data in an xarray format

    """

    # Get the formatted year, month and day parameter from the datespan
    request_dates = _format_cds_request_datespan(start_date, end_date)
    cds_params.update(request_dates)

    # Get the area corresponding to a position on the globe for a given grid
    # size
    # if both longitude and latitude are provided as number, select single
    # position
    if isinstance(longitude, (int, float)) or isinstance(
        latitude, (int, float)
    ):
        request_area = _format_cds_request_position(latitude, longitude, grid)
        cds_params.update(request_area)
    # if longitude or latitude is provided as list and the other one is either
    # None (in which case all latitudes or longitudes are selected) or also
    # provided as list, select area
    elif isinstance(longitude, list) or isinstance(latitude, list):
        if not isinstance(longitude, (int, float)) and not isinstance(
            latitude, (int, float)
        ):
            request_area = _format_cds_request_area(latitude, longitude, grid)
            cds_params.update(request_area)
        else:
            raise ValueError(
                "It is currently not supported that latitude or longitude is "
                "provided as a number while the other is provided as a list."
            )
    # in any other case no geographical subset is selected

    return _get_cds_data(**cds_params)

1	import logging	2✔
2	import os	2✔
3	from datetime import datetime	2✔
4	from datetime import timedelta	2✔
5	from tempfile import mkstemp	2✔
6
7	import cdsapi	2✔
8	import numpy as np	2✔
9	import xarray as xr	2✔
10
11	logger = logging.getLogger(__name__)	2✔
12
13
14	def _get_cds_data(	2✔
15	dataset_name="reanalysis-era5-single-levels",
16	target_file=None,
17	chunks=None,
18	cds_client=None,
19	**cds_params,
20	):
21	"""
22	Download data from the Climate Data Store (CDS)
23
24	Requirements:
25	* user account at https://cds.climate.copernicus.eu to use this function
26	* cdsapi package installed (https://cds.climate.copernicus.eu/api-how-to)
27
28	:param dataset_name: (str) short name of the dataset of the CDS. To find
29	it, click on a dataset found in
30	https://cds.climate.copernicus.eu/cdsapp#!/search?type=dataset and go
31	to the 'Download data' tab, then scroll down the page and click on
32	'Show API request', the short name is the string on the 6th line
33	after 'c.retrieve('
34	:param target_file: (str) name of the file to save downloaded locally
35	:param chunks: (dict)
36	:param cds_client: handle to CDS client (if none is provided, then it is
37	created)
38	:param cds_params: (dict) parameter to pass to the CDS request
39
40	:return: CDS data in an xarray format
41
42	"""
43
44	# https://cds.climate.copernicus.eu/api-how-to
45	if cds_client is None:	×
46	cds_client = cdsapi.Client()	×
47
48	# Default request
49	request = {	×
50	"format": "netcdf",
51	"product_type": "reanalysis",
52	"time": [
53	"00:00",
54	"01:00",
55	"02:00",
56	"03:00",
57	"04:00",
58	"05:00",
59	"06:00",
60	"07:00",
61	"08:00",
62	"09:00",
63	"10:00",
64	"11:00",
65	"12:00",
66	"13:00",
67	"14:00",
68	"15:00",
69	"16:00",
70	"17:00",
71	"18:00",
72	"19:00",
73	"20:00",
74	"21:00",
75	"22:00",
76	"23:00",
77	],
78	}
79
80	# Add user provided cds parameters to the request dict
81	request.update(cds_params)	×
82
83	assert {"year", "month", "variable"}.issubset(	×
84	request
85	), "Need to specify at least 'variable', 'year' and 'month'"
86
87	# Send the data request to the server
88	result = cds_client.retrieve(dataset_name, request)	×
89
90	no_target_file_provided = target_file is None	×
91	# Create a file in a secure way if a target filename was not provided
92	if no_target_file_provided is True:	×
93	fd, target_file = mkstemp(suffix=".nc")	×
94	os.close(fd)	×
95
96	logger.info(	×
97	"Downloading request for {} variables to {}".format(
98	len(request["variable"]), target_file
99	)
100	)
101
102	# Download the data in the target file
103	result.download(target_file)	×
104
105	# Extract the data from the target file
106	answer = xr.open_dataset(target_file, chunks=chunks)	×
107
108	# Now that the data has been extracted the file path is removed if it was
109	# not provided. This will currently not work on windows if the dataset is
110	# too large as the file will be locked by the reading process.
111	if no_target_file_provided is True:	×
112	os.unlink(target_file)	×
113
114	# Here yield might be preferable in case of large datasets
115	return answer	×
116
117
118	def _format_cds_request_datespan(start_date, end_date):	2✔
119	"""
120	Format the dates between two given dates in order to submit a CDS request
121
122	:param start_date: (str) start date of the range in YYYY-MM-DD format
123	:param end_date: (str) end date of the range in YYYY-MM-DD format
124
125	:return: a dict with the years, months and days of all the dates as lists
126	of string
127
128	"""
129
130	answer = {"year": [], "month": [], "day": []}	×
131	fmt = "%Y-%m-%d"	×
132	specific_fmt = {"year": "%4d", "month": "%02d", "day": "%02d"}	×
133	start_dt = datetime.strptime(start_date, fmt)	×
134	end_dt = datetime.strptime(end_date, fmt)	×
135
136	if end_dt < start_dt:	×
137	logger.warning(	×
138	"Swapping input dates as the end date '{}' is prior to the "
139	"start date '{}'.".format(end_date, start_date)
140	)
141	start_dt = end_dt	×
142	end_dt = datetime.strptime(start_date, fmt)	×
143
144	for n in range(int((end_dt - start_dt).days) + 1):	×
145	cur_dt = start_dt + timedelta(n)	×
146
147	# Add string value of the date's year, month and day to the
148	# corresponding lists in the dict which will be returned
149	for key, val in zip(	×
150	["year", "month", "day"], [cur_dt.year, cur_dt.month, cur_dt.day]
151	):
152	val = specific_fmt[key] % val	×
153	if val not in answer[key]:	×
154	answer[key].append(val)	×
155
156	# If the datespan is over more than a month, then all days are filled and
157	# the entire months are returned (for CDS request the days format for a
158	# full month is 31 days).
159	if len(answer["month"]) > 1:	×
160	answer["day"] = [str(d) for d in range(1, 32, 1)]	×
161
162	return answer	×
163
164
165	def _format_cds_request_area(	2✔
166	latitude_span=None, longitude_span=None, grid=None
167	):
168	"""
169	Format the area between two given latitude and longitude spans in order
170	to submit a CDS request
171
172	The grid convention of the era5 HRES is used with a native resolution of
173	0.28125 deg. For NetCDF format, the data is interpolated to a regular
174	lat/lon grid with 0.25 deg resolution.
175	In this grid the earth is modelled by a sphere with radius
176	R_E = 6367.47 km. Latitude values in the range [-90, 90] relative to the
177	equator and longitude values in the range [-180, 180]
178	relative to the Greenwich Prime Meridian [1].
179
180	References:
181	[1] https://confluence.ecmwf.int/display/CKB/ERA5%3A+What+is+the+spatial+reference
182	[2] https://confluence.ecmwf.int/display/UDOC/Post-processing+keywords
183
184	:param latitude_span: (list of float) formatted as [N,S]. The span is
185	between North and South latitudes (relative to the equator). North
186	corresponds to positive latitude [2].
187	:param longitude_span: (list of float) formatted as [W,E]. The span is
188	between East and West longitudes (relative to the Greenwich meridian).
189	East corresponds to positive longitude [2].
190	:param grid: (list of float) provide the latitude and longitude grid
191	resolutions in deg. It needs to be an integer fraction of 90 deg [2].
192
193	:return: a dict containing the grid and, if `latitude_span` and/or
194	`longitude_span` were specified, the area formatted for a CDS request
195
196	""" # noqa: E501
197
198	answer = {}	×
199
200	# Default value of the grid
201	if grid is None:	×
202	grid = [0.25, 0.25]	×
203
204	if latitude_span is not None and longitude_span is not None:	×
205	area = [	×
206	latitude_span[0],
207	longitude_span[0],
208	latitude_span[1],
209	longitude_span[1],
210	]
211	elif latitude_span is None and longitude_span is not None:	×
212	area = [90, longitude_span[0], -90, latitude_span[1]]	×
213	elif latitude_span is not None and longitude_span is None:	×
214	area = [latitude_span[0], -180, latitude_span[1], 180]	×
215	else:
216	area = []	×
217
218	# Format the 'grid' keyword of the CDS request as
219	# lat_resolution/lon_resolution
220	answer["grid"] = "%.2f/%.2f" % (grid[0], grid[1])	×
221
222	# Format the 'area' keyword of the CDS request as N/W/S/E
223	if area:	×
224	answer["area"] = "/".join(str(e) for e in area)	×
225
226	return answer	×
227
228
229	def _format_cds_request_position(latitude, longitude, grid=None):	2✔
230	"""
231	Reduce the area of a CDS request to a single GIS point on the earth grid
232
233	Find the closest grid point for the given longitude and latitude.
234
235	The grid convention of the era5 HRES is used here with a native
236	resolution of 0.28125 deg. For NetCDF format the data is interpolated to a
237	regular lat/lon grid with 0.25 deg resolution. In this grid the earth is
238	modelled by a sphere with radius R_E = 6367.47 km. latitude values
239	in the range [-90, 90] relative to the equator and longitude values in the
240	range [-180, 180] relative to the Greenwich Prime Meridian [1].
241
242	References:
243	[1] https://confluence.ecmwf.int/display/CKB/ERA5%3A+What+is+the+spatial+reference
244	[2] https://confluence.ecmwf.int/display/UDOC/Post-processing+keywords
245
246	:param latitude: (number) latitude in the range [-90, 90] relative to the
247	equator, north correspond to positive latitude.
248	:param longitude: (number) longitude in the range [-180, 180] relative to
249	Greenwich Meridian, east relative to the meridian correspond to
250	positive longitude.
251	:param grid: (list of float) provide the latitude and longitude grid
252	resolutions in deg. It needs to be an integer fraction of 90 deg [2].
253
254	:return: a dict containing the grid and the area formatted for a CDS
255	request
256
257	""" # noqa: E501
258
259	# Default value of the grid
260	if grid is None:	×
261	grid = [0.25, 0.25]	×
262
263	# Find the nearest point on the grid corresponding to the given latitude
264	# and longitude
265	grid_point = xr.Dataset(	×
266	{
267	"lat": np.arange(90, -90, -grid[0]),
268	"lon": np.arange(-180, 180.0, grid[1]),
269	}
270	).sel(lat=latitude, lon=longitude, method="nearest")
271
272	# Prepare an area which consists of only one grid point
273	lat, lon = [float(grid_point.coords[s]) for s in ("lat", "lon")]	×
274	return _format_cds_request_area(	×
275	latitude_span=[lat, lat], longitude_span=[lon, lon], grid=grid
276	)
277
278
279	def get_cds_data_from_datespan_and_position(	2✔
280	start_date,
281	end_date,
282	latitude=None,
283	longitude=None,
284	grid=None,
285	**cds_params,
286	):
287	"""
288	Format request for data from the Climate Data Store (CDS)
289
290	prepare a CDS request from user specified date span for a single grid point
291	closest to the specified latitude and longitude.
292
293	see _get_cds_data() for prior requirements and more information
294
295	:param start_date: (str) start date of the datespan in YYYY-MM-DD format
296	:param end_date: (str) end date of the datespan in YYYY-MM-DD format
297	:param latitude: (number or list of float or None)
298	* number: latitude in the range [-90, 90] relative to the
299	equator, north correspond to positive latitude.
300	* list of float: must be formatted as [N,S]. The span is
301	between North and South latitudes (relative to the equator). North
302	corresponds to positive latitude.
303	* None: No geographical subset is selected.
304	:param longitude: (number or list of float or None)
305	* number: longitude in the range [-180, 180] relative to
306	Greenwich Meridian, east relative to the meridian correspond to
307	positive longitude.
308	* list of float: must be formatted as [W,E]. The span is
309	between East and West longitudes (relative to the Greenwich meridian).
310	East corresponds to positive longitude
311	* None: No geographical subset is selected.
312	:param grid: (list of float) provide the latitude and longitude grid
313	resolutions in deg. It needs to be an integer fraction of 90 deg.
314	:param dataset_name: (str) short name of the dataset of the CDS. To find
315	it, click on a dataset found in
316	https://cds.climate.copernicus.eu/cdsapp#!/search?type=dataset and go
317	to the 'Download data' tab, then scroll down the page and click on
318	'Show API request', the short name is the string on the 6th line
319	after 'c.retrieve('
320	:param target_file: (str) name of the file in which downloading the data
321	locally
322	:param chunks: (dict)
323	:param cds_client: handle to CDS client (if none is provided, then it is
324	created)
325	:param cds_params: (dict) parameter to pass to the CDS request
326
327	:return: CDS data in an xarray format
328
329	"""
330
331	# Get the formatted year, month and day parameter from the datespan
332	request_dates = _format_cds_request_datespan(start_date, end_date)	×
333	cds_params.update(request_dates)	×
334
335	# Get the area corresponding to a position on the globe for a given grid
336	# size
337	# if both longitude and latitude are provided as number, select single
338	# position
339	if isinstance(longitude, (int, float)) or isinstance(	×
340	latitude, (int, float)
341	):
342	request_area = _format_cds_request_position(latitude, longitude, grid)	×
343	cds_params.update(request_area)	×
344	# if longitude or latitude is provided as list and the other one is either
345	# None (in which case all latitudes or longitudes are selected) or also
346	# provided as list, select area
347	elif isinstance(longitude, list) or isinstance(latitude, list):	×
348	if not isinstance(longitude, (int, float)) and not isinstance(	×
349	latitude, (int, float)
350	):
351	request_area = _format_cds_request_area(latitude, longitude, grid)	×
352	cds_params.update(request_area)	×
353	else:
354	raise ValueError(	×
355	"It is currently not supported that latitude or longitude is "
356	"provided as a number while the other is provided as a list."
357	)
358	# in any other case no geographical subset is selected
359
360	return _get_cds_data(**cds_params)	×

oemof / feedinlib / 940225349

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