def conform_units_to(self):
if self._conform_units_to is None:
ret = get_tuple([None] * len(get_tuple(self.variable)))
else:
ret = self._conform_units_to
ret = get_first_or_sequence(ret)
return ret
def units(self):
if self._units is None:
ret = get_tuple([None] * len(get_tuple(self.variable)))
else:
ret = self._units
ret = get_first_or_sequence(ret)
return ret
def conform_units_to(self, value):
if value is not None:
value = get_tuple(value)
if len(value) != len(get_tuple(self.variable)):
msg = 'Must match "variable" element-wise. The sequence lengths differ.'
raise RequestValidationError('conform_units_to', msg)
validate_units('conform_units_to', value)
self._conform_units_to = value
def units(self, value):
if value is not None:
value = get_tuple(value)
if len(value) != len(get_tuple(self.variable)):
msg = 'Must match "variable" element-wise. The sequence lengths differ.'
raise RequestValidationError('units', msg)
if env.USE_CFUNITS:
validate_units('units', value)
self._units = value
def units(self, value):
if value is not None:
value = get_tuple(value)
if len(value) != len(get_tuple(self.variable)):
msg = 'Must match "variable" element-wise. The sequence lengths differ.'
raise RequestValidationError('units', msg)
if env.USE_CFUNITS:
validate_units('units', value)
m = self.metadata['variables']
for v, u in zip(get_tuple(self.variable), value):
m[v]['attrs']['units'] = u
def units(self, value):
if value is not None:
value = get_tuple(value)
if len(value) != len(get_tuple(self.variable)):
msg = 'Must match "variable" element-wise. The sequence lengths differ.'
raise RequestValidationError('units', msg)
if env.USE_CFUNITS:
validate_units('units', value)
m = self.metadata['variables']
for v, u in zip(get_tuple(self.variable), value):
m[v]['attrs']['units'] = u
def conform_units_to(self, value):
if value is not None:
value = get_tuple(value)
if len(value) != len(get_tuple(self.variable)):
msg = 'Must match "variable" element-wise. The sequence lengths differ.'
raise RequestValidationError('units', msg)
if env.USE_CFUNITS:
validate_units('conform_units_to', value)
# If we are conforming units, assert that units are equivalent.
validate_unit_equivalence(get_tuple(self.units), value)
m = self.metadata['variables']
for v, u in zip(get_tuple(self.variable), value):
m[v]['conform_units_to'] = u
def conform_units_to(self, value):
if value is not None:
value = get_tuple(value)
if len(value) != len(get_tuple(self.variable)):
msg = 'Must match "variable" element-wise. The sequence lengths differ.'
raise RequestValidationError('units', msg)
if env.USE_CFUNITS:
validate_units('conform_units_to', value)
# If we are conforming units, assert that units are equivalent.
validate_unit_equivalence(get_tuple(self.units), value)
m = self.metadata['variables']
for v, u in zip(get_tuple(self.variable), value):
m[v]['conform_units_to'] = u
def test_get_tuple(self):
value = [4, 5]
ret = get_tuple(value)
self.assertEqual(ret, (4, 5))
value[1] = 10
self.assertEqual(value, [4, 10])
self.assertEqual(ret, (4, 5))
def get_source_metadata(self):
metadata = self.raw_metadata
try:
variables = get_tuple(self.rd.variable)
except NoDimensionedVariablesFound:
variables = None
try:
var = metadata["variables"][variables[0]]
except KeyError:
raise VariableNotFoundError(self.rd.uri, variables[0])
except TypeError:
# if there are no dimensioned variables available, the dimension map should not be set
if variables is not None:
raise
else:
if self.rd.dimension_map is None:
metadata["dim_map"] = get_dimension_map(var["name"], metadata)
else:
for k, v in self.rd.dimension_map.iteritems():
if not isinstance(v, dict):
try:
variable_name = metadata["variables"][v]["name"]
except KeyError:
variable_name = None
self.rd.dimension_map[k] = {
"variable": variable_name,
"dimension": v,
"pos": var["dimensions"].index(v),
}
metadata["dim_map"] = self.rd.dimension_map
return metadata
def variable(self):
if self._variable is None:
self._variable = get_tuple(self.driver.get_dimensioned_variables())
try:
ret = get_first_or_sequence(self._variable)
except IndexError:
raise NoDimensionedVariablesFound
return ret
def get_crs(self):
crs = None
for potential in itersubclasses(CFCoordinateReferenceSystem):
try:
crs = potential.load_from_metadata(get_tuple(self.rd.variable)[0], self.rd.source_metadata)
break
except ProjectionDoesNotMatch:
continue
return crs
def _write_dataset_identifier_file_(path, ops):
from ocgis.conv.csv_ import OcgDialect
rows = []
headers = [
'DID', 'VARIABLE', 'STANDARD_NAME', 'LONG_NAME', 'UNITS', 'URI',
'GROUP'
]
with open(path, 'w') as f:
writer = csv.DictWriter(f, headers, dialect=OcgDialect)
writer.writeheader()
# writer.writerow(headers)
for element in ops.dataset:
row_template = {'DID': element.uid}
if element.has_data_variables:
try:
itr = get_iter(element.variable)
except AttributeError:
itr = element.get_by_tag(TagName.DATA_VARIABLES)
for idx, variable in enumerate(itr):
row = row_template.copy()
try:
attrs = variable.attrs
units = variable.units
group = variable.group
uri = None
variable_name = variable.name
except AttributeError:
attrs = element.metadata['variables'][variable][
'attrs']
units = get_tuple(element.units)[idx]
group = None
uri = element.uri
variable_name = variable
row['STANDARD_NAME'] = attrs.get('standard_name')
row['LONG_NAME'] = attrs.get('long_name')
row['UNITS'] = units
row['GROUP'] = group
row['URI'] = uri
row['VARIABLE'] = variable_name
rows.append(row)
writer.writerows(rows)
def _write_dataset_identifier_file_(path, ops):
from ocgis.conv.csv_ import OcgDialect
rows = []
headers = ['DID', 'VARIABLE', 'STANDARD_NAME', 'LONG_NAME', 'UNITS', 'URI', 'GROUP']
with open(path, 'w') as f:
writer = csv.DictWriter(f, headers, dialect=OcgDialect)
writer.writeheader()
# writer.writerow(headers)
for element in ops.dataset:
row_template = {'DID': element.uid}
if element.has_data_variables:
try:
itr = get_iter(element.variable)
except AttributeError:
itr = element.get_by_tag(TagName.DATA_VARIABLES)
for idx, variable in enumerate(itr):
row = row_template.copy()
try:
attrs = variable.attrs
units = variable.units
group = variable.group
uri = None
variable_name = variable.name
except AttributeError:
attrs = element.metadata['variables'][variable]['attrs']
units = get_tuple(element.units)[idx]
group = None
uri = element.uri
variable_name = variable
row['STANDARD_NAME'] = attrs.get('standard_name')
row['LONG_NAME'] = attrs.get('long_name')
row['UNITS'] = units
row['GROUP'] = group
row['URI'] = uri
row['VARIABLE'] = variable_name
rows.append(row)
writer.writerows(rows)
def rename_variable(self, value):
value = get_tuple(value)
self._rename_variable = value
def __init__(self, uri=None, variable=None, alias=None, units=None, time_range=None, time_region=None,
time_subset_func=None, level_range=None, conform_units_to=None, crs=None, t_units=None,
t_calendar=None, t_conform_units_to=None, did=None, meta=None, s_abstraction=None, dimension_map=None,
name=None, driver=None, regrid_source=True, regrid_destination=False):
self._alias = None
self._conform_units_to = None
self._name = None
self._level_range = None
self._time_range = None
self._time_range = None
self._time_subset_func = None
self._units = None
self._dimension_map = deepcopy(dimension_map)
self._is_init = True
# flag used for regridding to determine if the coordinate system was assigned during initialization
self._has_assigned_coordinate_system = False if crs is None else True
self._source_metadata = None
if uri is None:
raise RequestValidationError('uri', 'Cannot be None')
else:
self._uri = self._get_uri_(uri)
if driver is None:
klass = self._get_autodiscovered_driver_(self.uri)
else:
try:
klass = self._Drivers[driver]
except KeyError:
raise RequestValidationError('driver', 'Driver not found: {0}'.format(driver))
self.driver = klass(self)
if variable is not None:
variable = get_tuple(variable)
self._variable = variable
self.alias = alias
self.name = name
self.time_range = time_range
self.time_region = time_region
self.time_subset_func = time_subset_func
self.level_range = level_range
self._crs = deepcopy(crs)
self.t_units = t_units
self.t_calendar = t_calendar
self.t_conform_units_to = t_conform_units_to
self.did = did
self.meta = meta or {}
self.units = units
self.conform_units_to = conform_units_to
self.s_abstraction = s_abstraction
try:
self.s_abstraction = self.s_abstraction.lower()
assert self.s_abstraction in ('point', 'polygon')
except AttributeError:
if s_abstraction is None:
pass
else:
raise
self.regrid_source = regrid_source
self.regrid_destination = regrid_destination
self._is_init = False
self._validate_time_subset_()
def __iter__(self):
attrs = ['alias', 'variable', 'units', 'conform_units_to']
for ii in range(len(self)):
yield {a: get_tuple(getattr(self, a))[ii] for a in attrs}
def __len__(self):
try:
ret = len(get_tuple(self.variable))
except NoDimensionedVariablesFound:
ret = 0
return ret
def alias(self):
if self._alias is None:
ret = get_tuple(self.variable)
else:
ret = self._alias
return get_first_or_sequence(ret)
def __len__(self):
try:
ret = len(get_tuple(self.variable))
except NoDataVariablesFound:
ret = 0
return ret
def __iter__(self):
attrs = ['variable', 'units', 'conform_units_to']
for ii in range(len(self)):
yield {a: get_tuple(getattr(self, a))[ii] for a in attrs}
def __init__(self,
uri=None,
variable=None,
units=None,
time_range=None,
time_region=None,
time_subset_func=None,
level_range=None,
conform_units_to=None,
crs='auto',
t_units=None,
t_calendar=None,
t_conform_units_to=None,
grid_abstraction='auto',
grid_is_isomorphic='auto',
dimension_map=None,
field_name=None,
driver=None,
regrid_source=True,
regrid_destination=False,
metadata=None,
format_time=True,
opened=None,
uid=None,
rename_variable=None,
predicate=None,
rotated_pole_priority=False,
driver_kwargs=None):
self._is_init = True
self._field_name = field_name
self._level_range = None
self._time_range = None
self._time_region = None
self._time_subset_func = None
self._driver_kwargs = driver_kwargs
if rename_variable is not None:
rename_variable = get_tuple(rename_variable)
self._rename_variable = rename_variable
self.rotated_pole_priority = rotated_pole_priority
self.predicate = predicate
if dimension_map is not None and isinstance(dimension_map, dict):
dimension_map = DimensionMap.from_dict(dimension_map)
self._dimension_map = dimension_map
self._metadata = deepcopy(metadata)
self._uri = None
self.uid = uid
# This is an "open" file-like object that may be passed in-place of file location parameters.
self._opened = opened
if opened is not None and driver is None:
msg = 'If "opened" is not None, then a "driver" must be provided.'
ocgis_lh(logger='request',
exc=RequestValidationError('driver', msg))
# Field creation options.
self.format_time = format_time
self.grid_abstraction = grid_abstraction
self.grid_is_isomorphic = grid_is_isomorphic
# Flag used for regridding to determine if the coordinate system was assigned during initialization.
self._has_assigned_coordinate_system = False if crs == 'auto' else True
if uri is None:
# Fields may be created from pure metadata.
if metadata is not None:
# The default OCGIS driver is NetCDF.
if driver is None:
driver = DriverKey.NETCDF_CF
elif opened is None:
ocgis_lh(logger='request',
exc=RequestValidationError('uri', 'Cannot be None'))
else:
self._uri = get_uri(uri)
if driver is None:
klass = get_autodiscovered_driver(uri)
else:
klass = get_driver(driver)
self._driver = klass(self)
if variable is not None:
variable = get_tuple(variable)
self._variable = variable
self.time_range = time_range
self.time_region = time_region
self.time_subset_func = time_subset_func
self.level_range = level_range
self._crs = deepcopy(crs)
self.regrid_source = regrid_source
self.regrid_destination = regrid_destination
self.units = units
self.conform_units_to = conform_units_to
self._is_init = False
self._validate_time_subset_()
# Update metadata for time variable.
tvar = self.dimension_map.get_variable(DMK.TIME)
if tvar is not None:
m = self.metadata['variables'][tvar]
if t_units is not None:
m['attrs']['units'] = t_units
if t_calendar is not None:
m['attrs']['calendar'] = t_calendar
if t_conform_units_to is not None:
from ocgis.util.units import get_units_object
t_calendar = m['attrs'].get(
'calendar', constants.DEFAULT_TEMPORAL_CALENDAR)
t_conform_units_to = get_units_object(t_conform_units_to,
calendar=t_calendar)
m['conform_units_to'] = t_conform_units_to
def alias(self, value):
if value is not None:
self._alias = get_tuple(value)
if len(self._alias) != len(get_tuple(self.variable)):
raise RequestValidationError('alias', 'Each variable must have an alias. The sequence lengths differ.')
def name(self):
if self._name is None:
ret = '_'.join(get_tuple(self.alias))
else:
ret = self._name
return ret
def __init__(self, uri=None, variable=None, units=None, time_range=None, time_region=None,
time_subset_func=None, level_range=None, conform_units_to=None, crs='auto', t_units=None,
t_calendar=None, t_conform_units_to=None, grid_abstraction='auto', grid_is_isomorphic='auto',
dimension_map=None, field_name=None, driver=None, regrid_source=True, regrid_destination=False,
metadata=None, format_time=True, opened=None, uid=None, rename_variable=None, predicate=None,
rotated_pole_priority=False, driver_kwargs=None, decomp_type=DecompositionType.OCGIS):
self._is_init = True
self._field_name = field_name
self._level_range = None
self._time_range = None
self._time_region = None
self._time_subset_func = None
self._driver_kwargs = driver_kwargs
self._decomp_type = decomp_type
if rename_variable is not None:
rename_variable = get_tuple(rename_variable)
self._rename_variable = rename_variable
self.rotated_pole_priority = rotated_pole_priority
self.predicate = predicate
if dimension_map is not None and isinstance(dimension_map, dict):
dimension_map = DimensionMap.from_dict(dimension_map)
self._dimension_map = dimension_map
self._metadata = deepcopy(metadata)
self._uri = None
self.uid = uid
# This is an "open" file-like object that may be passed in-place of file location parameters.
self._opened = opened
if opened is not None and driver is None:
msg = 'If "opened" is not None, then a "driver" must be provided.'
ocgis_lh(logger='request', exc=RequestValidationError('driver', msg))
# Field creation options.
self.format_time = format_time
self.grid_abstraction = grid_abstraction
self.grid_is_isomorphic = grid_is_isomorphic
# Flag used for regridding to determine if the coordinate system was assigned during initialization.
self._has_assigned_coordinate_system = False if crs == 'auto' else True
if uri is None:
# Fields may be created from pure metadata.
if metadata is not None:
# The default OCGIS driver is NetCDF.
if driver is None:
driver = DriverKey.NETCDF_CF
elif opened is None:
ocgis_lh(logger='request', exc=RequestValidationError('uri', 'Cannot be None'))
else:
self._uri = get_uri(uri)
if driver is None:
klass = get_autodiscovered_driver(uri)
else:
klass = get_driver(driver)
self._driver = klass(self)
if variable is not None:
variable = get_tuple(variable)
self._variable = variable
self.time_range = time_range
self.time_region = time_region
self.time_subset_func = time_subset_func
self.level_range = level_range
self._crs = deepcopy(crs)
self.regrid_source = regrid_source
self.regrid_destination = regrid_destination
self.units = units
self.conform_units_to = conform_units_to
self._is_init = False
self._validate_time_subset_()
# Update metadata for time variable.
tvar = self.dimension_map.get_variable(DMK.TIME)
if tvar is not None:
m = self.metadata['variables'][tvar]
if t_units is not None:
m['attrs']['units'] = t_units
if t_calendar is not None:
m['attrs']['calendar'] = t_calendar
if t_conform_units_to is not None:
from ocgis.util.units import get_units_object
t_calendar = m['attrs'].get('calendar', constants.DEFAULT_TEMPORAL_CALENDAR)
t_conform_units_to = get_units_object(t_conform_units_to, calendar=t_calendar)
m['conform_units_to'] = t_conform_units_to
