pydune.data_processing.meteorological.downloadCDS.Dataset#

class Dataset#

Bases: object

A netCDF Dataset is a collection of dimensions, groups, variables and attributes. Together they describe the meaning of data and relations among data fields stored in a netCDF file. See Dataset.__init__ for more details.

A list of attribute names corresponding to global netCDF attributes defined for the Dataset can be obtained with the Dataset.ncattrs method. These attributes can be created by assigning to an attribute of the Dataset instance. A dictionary containing all the netCDF attribute name/value pairs is provided by the __dict__ attribute of a Dataset instance.

The following class variables are read-only and should not be modified by the user.

`dimensions`: The dimensions dictionary maps the names of dimensions defined for the Group or Dataset to instances of the Dimension class.

`variables`: The variables dictionary maps the names of variables defined for this Dataset or Group to instances of the Variable class.

`groups`: The groups dictionary maps the names of groups created for this Dataset or Group to instances of the Group class (the Dataset class is simply a special case of the Group class which describes the root group in the netCDF4 file).

`cmptypes`: The cmptypes dictionary maps the names of compound types defined for the Group or Dataset to instances of the CompoundType class.

`vltypes`: The vltypes dictionary maps the names of variable-length types defined for the Group or Dataset to instances of the VLType class.

`enumtypes`: The enumtypes dictionary maps the names of Enum types defined for the Group or Dataset to instances of the EnumType class.

`data_model`: data_model describes the netCDF data model version, one of NETCDF3_CLASSIC, NETCDF4, NETCDF4_CLASSIC, NETCDF3_64BIT_OFFSET or NETCDF3_64BIT_DATA.

`file_format`: same as data_model, retained for backwards compatibility.

`disk_format`: disk_format describes the underlying file format, one of NETCDF3, HDF5, HDF4, PNETCDF, DAP2, DAP4 or UNDEFINED. Only available if using netcdf C library version >= 4.3.1, otherwise will always return UNDEFINED.

`parent`: parent is a reference to the parent Group instance. None for the root group or Dataset instance.

`path`: path shows the location of the Group in the Dataset in a unix directory format (the names of groups in the hierarchy separated by backslashes). A Dataset instance is the root group, so the path is simply ‘/’.

`keepweakref`: If True, child Dimension and Variables objects only keep weak references to the parent Dataset or Group.

`_ncstring_attrs__`: If True, all text attributes will be written as variable-length strings.

Attributes:

auto_complex
cmptypes
data_model
dimensions
disk_format
enumtypes
file_format
groups
keepweakref
name: string name of Group instance
parent
path
variables
vltypes

Methods

`close`()	`close(self)`
`createCompoundType`(datatype, datatype_name)	`createCompoundType(self, datatype, datatype_name)`
`createDimension`(dimname[, size])	`createDimension(self, dimname, size=None)`
`createEnumType`(datatype, datatype_name, ...)	`createEnumType(self, datatype, datatype_name, enum_dict)`
`createGroup`(groupname)	`createGroup(self, groupname)`
`createVLType`(datatype, datatype_name)	`createVLType(self, datatype, datatype_name)`
`createVariable`(varname, datatype[, ...])	`createVariable(self, varname, datatype, dimensions=(), compression=None, zlib=False, complevel=4, shuffle=True, fletcher32=False, contiguous=False, chunksizes=None, szip_coding='nn', szip_pixels_per_block=8, blosc_shuffle=1, endian='native', least_significant_digit=None, significant_digits=None, quantize_mode='BitGroom', fill_value=None, chunk_cache=None)`
`delncattr`(name)	`delncattr(self,name,value)`
`filepath`([encoding])	`filepath(self,encoding=None)`
`fromcdl`(cdlfilename[, ncfilename, mode, format])	`fromcdl(cdlfilename, ncfilename=None, mode='a',format='NETCDF4')`
`get_variables_by_attributes`(**kwargs)	`get_variables_by_attributes(self, kwargs)`**
`getncattr`(name[, encoding])	`getncattr(self,name)`
`has_blosc_filter`()	`has_blosc_filter(self)` returns True if blosc compression filter is available
`has_bzip2_filter`()	`has_bzip2_filter(self)` returns True if bzip2 compression filter is available
`has_szip_filter`()	`has_szip_filter(self)` returns True if szip compression filter is available
`has_zstd_filter`()	`has_zstd_filter(self)` returns True if zstd compression filter is available
`isopen`()	`isopen(self)`
`ncattrs`()	`ncattrs(self)`
`renameAttribute`(oldname, newname)	`renameAttribute(self, oldname, newname)`
`renameDimension`(oldname, newname)	`renameDimension(self, oldname, newname)`
`renameGroup`(oldname, newname)	`renameGroup(self, oldname, newname)`
`renameVariable`(oldname, newname)	`renameVariable(self, oldname, newname)`
`set_always_mask`(value)	`set_always_mask(self, True_or_False)`
`set_auto_chartostring`(value)	`set_auto_chartostring(self, True_or_False)`
`set_auto_mask`(value)	`set_auto_mask(self, True_or_False)`
`set_auto_maskandscale`(value)	`set_auto_maskandscale(self, True_or_False)`
`set_auto_scale`(value)	`set_auto_scale(self, True_or_False)`
`set_fill_off`()	`set_fill_off(self)`
`set_fill_on`()	`set_fill_on(self)`
`set_ncstring_attrs`(value)	`set_ncstring_attrs(self, True_or_False)`
`setncattr`(name, value)	`setncattr(self,name,value)`
`setncattr_string`(name, value)	`setncattr_string(self,name,value)`
`setncatts`(attdict)	`setncatts(self,attdict)`
`sync`()	`sync(self)`
`tocdl`([coordvars, data, outfile])	`tocdl(self, coordvars=False, data=False, outfile=None)`

`__init__(self, filename, mode=”r”, clobber=True, diskless=False, persist=False, keepweakref=False, memory=None, encoding=None, parallel=False, comm=None, info=None, format=’NETCDF4’)`

Dataset constructor.

`filename`: Name of netCDF file to hold dataset. Can also be a python 3 pathlib instance or the URL of an OpenDAP dataset. When memory is set this is just used to set the filepath().

`mode`: access mode. r means read-only; no data can be modified. w means write; a new file is created, an existing file with the same name is deleted. x means write, but fail if an existing file with the same name already exists. a and r+ mean append; an existing file is opened for reading and writing, if file does not exist already, one is created. Appending s to modes r, w, r+ or a will enable unbuffered shared access to NETCDF3_CLASSIC, NETCDF3_64BIT_OFFSET or NETCDF3_64BIT_DATA formatted files. Unbuffered access may be useful even if you don’t need shared access, since it may be faster for programs that don’t access data sequentially. This option is ignored for NETCDF4 and NETCDF4_CLASSIC formatted files.

`clobber`: if True (default), opening a file with mode=’w’ will clobber an existing file with the same name. if False, an exception will be raised if a file with the same name already exists. mode=`x` is identical to mode=`w` with clobber=False.

`format`: underlying file format (one of ‘NETCDF4’, ‘NETCDF4_CLASSIC’, ‘NETCDF3_CLASSIC’, ‘NETCDF3_64BIT_OFFSET’ or ‘NETCDF3_64BIT_DATA’. Only relevant if mode = ‘w’ (if mode = ‘r’,’a’ or ‘r+’ the file format is automatically detected). Default ‘NETCDF4’, which means the data is stored in an HDF5 file, using netCDF 4 API features. Setting format=’NETCDF4_CLASSIC’ will create an HDF5 file, using only netCDF 3 compatible API features. netCDF 3 clients must be recompiled and linked against the netCDF 4 library to read files in NETCDF4_CLASSIC format. ‘NETCDF3_CLASSIC’ is the classic netCDF 3 file format that does not handle 2+ Gb files. ‘NETCDF3_64BIT_OFFSET’ is the 64-bit offset version of the netCDF 3 file format, which fully supports 2+ GB files, but is only compatible with clients linked against netCDF version 3.6.0 or later. ‘NETCDF3_64BIT_DATA’ is the 64-bit data version of the netCDF 3 file format, which supports 64-bit dimension sizes plus unsigned and 64 bit integer data types, but is only compatible with clients linked against netCDF version 4.4.0 or later.

`diskless`: If True, create diskless (in-core) file. This is a feature added to the C library after the netcdf-4.2 release. If you need to access the memory buffer directly, use the in-memory feature instead (see memory kwarg).

`persist`: if diskless=True, persist file to disk when closed (default False).

`keepweakref`: if True, child Dimension and Variable instances will keep weak references to the parent Dataset or Group object. Default is False, which means strong references will be kept. Having Dimension and Variable instances keep a strong reference to the parent Dataset instance, which in turn keeps a reference to child Dimension and Variable instances, creates circular references. Circular references complicate garbage collection, which may mean increased memory usage for programs that create may Dataset instances with lots of Variables. It also will result in the Dataset object never being deleted, which means it may keep open files alive as well. Setting keepweakref=True allows Dataset instances to be garbage collected as soon as they go out of scope, potentially reducing memory usage and open file handles. However, in many cases this is not desirable, since the associated Variable instances may still be needed, but are rendered unusable when the parent Dataset instance is garbage collected.

`memory`: if not None, create or open an in-memory Dataset. If mode = r, the memory kwarg must contain a memory buffer object (an object that supports the python buffer interface). The Dataset will then be created with contents taken from this block of memory. If mode = w, the memory kwarg should contain the anticipated size of the Dataset in bytes (used only for NETCDF3 files). A memory buffer containing a copy of the Dataset is returned by the Dataset.close method. Requires netcdf-c version 4.4.1 for mode=`r` netcdf-c 4.6.2 for mode=`w`. To persist the file to disk, the raw bytes from the returned buffer can be written into a binary file. The Dataset can also be re-opened using this memory buffer.

`encoding`: encoding used to encode filename string into bytes. Default is None (sys.getdefaultfileencoding() is used).

`parallel`: open for parallel access using MPI (requires mpi4py and parallel-enabled netcdf-c and hdf5 libraries). Default is False. If True, comm and info kwargs may also be specified.

`comm`: MPI_Comm object for parallel access. Default None, which means MPI_COMM_WORLD will be used. Ignored if parallel=False.

`info`: MPI_Info object for parallel access. Default None, which means MPI_INFO_NULL will be used. Ignored if parallel=False.

`auto_complex`: if True, then automatically convert complex number types

Attributes:

auto_complex
cmptypes
data_model
dimensions
disk_format
enumtypes
file_format
groups
keepweakref
name: string name of Group instance
parent
path
variables
vltypes

Methods

`close`()	`close(self)`
`createCompoundType`(datatype, datatype_name)	`createCompoundType(self, datatype, datatype_name)`
`createDimension`(dimname[, size])	`createDimension(self, dimname, size=None)`
`createEnumType`(datatype, datatype_name, ...)	`createEnumType(self, datatype, datatype_name, enum_dict)`
`createGroup`(groupname)	`createGroup(self, groupname)`
`createVLType`(datatype, datatype_name)	`createVLType(self, datatype, datatype_name)`
`createVariable`(varname, datatype[, ...])	`createVariable(self, varname, datatype, dimensions=(), compression=None, zlib=False, complevel=4, shuffle=True, fletcher32=False, contiguous=False, chunksizes=None, szip_coding='nn', szip_pixels_per_block=8, blosc_shuffle=1, endian='native', least_significant_digit=None, significant_digits=None, quantize_mode='BitGroom', fill_value=None, chunk_cache=None)`
`delncattr`(name)	`delncattr(self,name,value)`
`filepath`([encoding])	`filepath(self,encoding=None)`
`fromcdl`(cdlfilename[, ncfilename, mode, format])	`fromcdl(cdlfilename, ncfilename=None, mode='a',format='NETCDF4')`
`get_variables_by_attributes`(**kwargs)	`get_variables_by_attributes(self, kwargs)`**
`getncattr`(name[, encoding])	`getncattr(self,name)`
`has_blosc_filter`()	`has_blosc_filter(self)` returns True if blosc compression filter is available
`has_bzip2_filter`()	`has_bzip2_filter(self)` returns True if bzip2 compression filter is available
`has_szip_filter`()	`has_szip_filter(self)` returns True if szip compression filter is available
`has_zstd_filter`()	`has_zstd_filter(self)` returns True if zstd compression filter is available
`isopen`()	`isopen(self)`
`ncattrs`()	`ncattrs(self)`
`renameAttribute`(oldname, newname)	`renameAttribute(self, oldname, newname)`
`renameDimension`(oldname, newname)	`renameDimension(self, oldname, newname)`
`renameGroup`(oldname, newname)	`renameGroup(self, oldname, newname)`
`renameVariable`(oldname, newname)	`renameVariable(self, oldname, newname)`
`set_always_mask`(value)	`set_always_mask(self, True_or_False)`
`set_auto_chartostring`(value)	`set_auto_chartostring(self, True_or_False)`
`set_auto_mask`(value)	`set_auto_mask(self, True_or_False)`
`set_auto_maskandscale`(value)	`set_auto_maskandscale(self, True_or_False)`
`set_auto_scale`(value)	`set_auto_scale(self, True_or_False)`
`set_fill_off`()	`set_fill_off(self)`
`set_fill_on`()	`set_fill_on(self)`
`set_ncstring_attrs`(value)	`set_ncstring_attrs(self, True_or_False)`
`setncattr`(name, value)	`setncattr(self,name,value)`
`setncattr_string`(name, value)	`setncattr_string(self,name,value)`
`setncatts`(attdict)	`setncatts(self,attdict)`
`sync`()	`sync(self)`
`tocdl`([coordvars, data, outfile])	`tocdl(self, coordvars=False, data=False, outfile=None)`

Methods

`close`	`close(self)`
`createCompoundType`	`createCompoundType(self, datatype, datatype_name)`
`createDimension`	`createDimension(self, dimname, size=None)`
`createEnumType`	`createEnumType(self, datatype, datatype_name, enum_dict)`
`createGroup`	`createGroup(self, groupname)`
`createVLType`	`createVLType(self, datatype, datatype_name)`
`createVariable`	`createVariable(self, varname, datatype, dimensions=(), compression=None, zlib=False, complevel=4, shuffle=True, fletcher32=False, contiguous=False, chunksizes=None, szip_coding='nn', szip_pixels_per_block=8, blosc_shuffle=1, endian='native', least_significant_digit=None, significant_digits=None, quantize_mode='BitGroom', fill_value=None, chunk_cache=None)`
`delncattr`	`delncattr(self,name,value)`
`filepath`	`filepath(self,encoding=None)`
`fromcdl`	`fromcdl(cdlfilename, ncfilename=None, mode='a',format='NETCDF4')`
`get_variables_by_attributes`	`get_variables_by_attributes(self, kwargs)`**
`getncattr`	`getncattr(self,name)`
`has_blosc_filter`	`has_blosc_filter(self)` returns True if blosc compression filter is available
`has_bzip2_filter`	`has_bzip2_filter(self)` returns True if bzip2 compression filter is available
`has_szip_filter`	`has_szip_filter(self)` returns True if szip compression filter is available
`has_zstd_filter`	`has_zstd_filter(self)` returns True if zstd compression filter is available
`isopen`	`isopen(self)`
`ncattrs`	`ncattrs(self)`
`renameAttribute`	`renameAttribute(self, oldname, newname)`
`renameDimension`	`renameDimension(self, oldname, newname)`
`renameGroup`	`renameGroup(self, oldname, newname)`
`renameVariable`	`renameVariable(self, oldname, newname)`
`set_always_mask`	`set_always_mask(self, True_or_False)`
`set_auto_chartostring`	`set_auto_chartostring(self, True_or_False)`
`set_auto_mask`	`set_auto_mask(self, True_or_False)`
`set_auto_maskandscale`	`set_auto_maskandscale(self, True_or_False)`
`set_auto_scale`	`set_auto_scale(self, True_or_False)`
`set_fill_off`	`set_fill_off(self)`
`set_fill_on`	`set_fill_on(self)`
`set_ncstring_attrs`	`set_ncstring_attrs(self, True_or_False)`
`setncattr`	`setncattr(self,name,value)`
`setncattr_string`	`setncattr_string(self,name,value)`
`setncatts`	`setncatts(self,attdict)`
`sync`	`sync(self)`
`tocdl`	`tocdl(self, coordvars=False, data=False, outfile=None)`

Attributes

`auto_complex`
`cmptypes`
`data_model`
`dimensions`
`disk_format`
`enumtypes`
`file_format`
`groups`
`keepweakref`
`name`	string name of Group instance
`parent`
`path`
`variables`
`vltypes`

close()#

`close(self)`

Close the Dataset.

createCompoundType(datatype, datatype_name)#

`createCompoundType(self, datatype, datatype_name)`

Creates a new compound data type named datatype_name from the numpy dtype object datatype.

*Note*: If the new compound data type contains other compound data types (i.e. it is a ‘nested’ compound type, where not all of the elements are homogeneous numeric data types), then the ‘inner’ compound types must be created first.

The return value is the CompoundType class instance describing the new datatype.

createDimension(dimname, size=None)#

`createDimension(self, dimname, size=None)`

Creates a new dimension with the given dimname and size.

size must be a positive integer or None, which stands for “unlimited” (default is None). Specifying a size of 0 also results in an unlimited dimension. The return value is the Dimension class instance describing the new dimension. To determine the current maximum size of the dimension, use the len function on the Dimension instance. To determine if a dimension is ‘unlimited’, use the Dimension.isunlimited method of the Dimension instance.

createEnumType(datatype, datatype_name, enum_dict)#

`createEnumType(self, datatype, datatype_name, enum_dict)`

Creates a new Enum data type named datatype_name from a numpy integer dtype object datatype, and a python dictionary defining the enum fields and values.

The return value is the EnumType class instance describing the new datatype.

createGroup(groupname)#

`createGroup(self, groupname)`

Creates a new Group with the given groupname.

If groupname is specified as a path, using forward slashes as in unix to separate components, then intermediate groups will be created as necessary (analogous to mkdir -p in unix). For example, createGroup(‘/GroupA/GroupB/GroupC’) will create GroupA, GroupA/GroupB, and GroupA/GroupB/GroupC, if they don’t already exist. If the specified path describes a group that already exists, no error is raised.

The return value is a Group class instance.

createVLType(datatype, datatype_name)#

`createVLType(self, datatype, datatype_name)`

Creates a new VLEN data type named datatype_name from a numpy dtype object datatype.

The return value is the VLType class instance describing the new datatype.

createVariable(varname, datatype, dimensions=(), compression=None, zlib=False, complevel=4, shuffle=True, szip_coding='nn', szip_pixels_per_block=8, blosc_shuffle=1, fletcher32=False, contiguous=False, chunksizes=None, endian='native', least_significant_digit=None, significant_digits=None, quantize_mode='BitGroom', fill_value=None, chunk_cache=None)#

`createVariable(self, varname, datatype, dimensions=(), compression=None, zlib=False, complevel=4, shuffle=True, fletcher32=False, contiguous=False, chunksizes=None, szip_coding=’nn’, szip_pixels_per_block=8, blosc_shuffle=1, endian=’native’, least_significant_digit=None, significant_digits=None, quantize_mode=’BitGroom’, fill_value=None, chunk_cache=None)`

Creates a new variable with the given varname, datatype, and dimensions. If dimensions are not given, the variable is assumed to be a scalar.

If varname is specified as a path, using forward slashes as in unix to separate components, then intermediate groups will be created as necessary For example, createVariable(‘/GroupA/GroupB/VarC’, float, (‘x’,’y’)) will create groups GroupA and GroupA/GroupB, plus the variable GroupA/GroupB/VarC, if the preceding groups don’t already exist.

The datatype can be a numpy datatype object, or a string that describes a numpy dtype object (like the dtype.str attribute of a numpy array). Supported specifiers include: ‘S1’ or ‘c’ (NC_CHAR), ‘i1’ or ‘b’ or ‘B’ (NC_BYTE), ‘u1’ (NC_UBYTE), ‘i2’ or ‘h’ or ‘s’ (NC_SHORT), ‘u2’ (NC_USHORT), ‘i4’ or ‘i’ or ‘l’ (NC_INT), ‘u4’ (NC_UINT), ‘i8’ (NC_INT64), ‘u8’ (NC_UINT64), ‘f4’ or ‘f’ (NC_FLOAT), ‘f8’ or ‘d’ (NC_DOUBLE). datatype can also be a CompoundType instance (for a structured, or compound array), a VLType instance (for a variable-length array), or the python str builtin (for a variable-length string array). Numpy string and unicode datatypes with length greater than one are aliases for str.

Data from netCDF variables is presented to python as numpy arrays with the corresponding data type.

dimensions must be a tuple containing Dimension instances and/or dimension names (strings) that have been defined previously using Dataset.createDimension. The default value is an empty tuple, which means the variable is a scalar.

If the optional keyword argument compression is set, the data will be compressed in the netCDF file using the specified compression algorithm. Currently zlib,`szip`,`zstd`,`bzip2`,`blosc_lz`,`blosc_lz4`,`blosc_lz4hc`, blosc_zlib and blosc_zstd are supported. Default is None (no compression). All of the compressors except zlib and szip use the HDF5 plugin architecture.

If the optional keyword zlib is True, the data will be compressed in the netCDF file using zlib compression (default False). The use of this option is deprecated in favor of compression=’zlib’.

The optional keyword complevel is an integer between 0 and 9 describing the level of compression desired (default 4). Ignored if compression=None. A value of zero disables compression.

If the optional keyword shuffle is True, the HDF5 shuffle filter will be applied before compressing the data with zlib (default True). This significantly improves compression. Default is True. Ignored if zlib=False.

The optional kwarg blosc_shuffle`is ignored unless the blosc compressor is used. `blosc_shuffle can be 0 (no shuffle), 1 (byte-wise shuffle) or 2 (bit-wise shuffle). Default is 1.

The optional kwargs szip_coding and szip_pixels_per_block are ignored unless the szip compressor is used. szip_coding can be ec (entropy coding) or nn (nearest neighbor coding). Default is nn. szip_pixels_per_block can be 4, 8, 16 or 32 (default 8).

If the optional keyword fletcher32 is True, the Fletcher32 HDF5 checksum algorithm is activated to detect errors. Default False.

If the optional keyword contiguous is True, the variable data is stored contiguously on disk. Default False. Setting to True for a variable with an unlimited dimension will trigger an error. Fixed size variables (with no unlimited dimension) with no compression filters are contiguous by default.

The optional keyword chunksizes can be used to manually specify the HDF5 chunksizes for each dimension of the variable. A detailed discussion of HDF chunking and I/O performance is available [here](https://support.hdfgroup.org/HDF5/doc/Advanced/Chunking). The default chunking scheme in the netcdf-c library is discussed [here](https://www.unidata.ucar.edu/software/netcdf/documentation/NUG/netcdf_perf_chunking.html). Basically, you want the chunk size for each dimension to match as closely as possible the size of the data block that users will read from the file. chunksizes cannot be set if contiguous=True.

The optional keyword endian can be used to control whether the data is stored in little or big endian format on disk. Possible values are little, big or native (default). The library will automatically handle endian conversions when the data is read, but if the data is always going to be read on a computer with the opposite format as the one used to create the file, there may be some performance advantage to be gained by setting the endian-ness.

The optional keyword fill_value can be used to override the default netCDF _FillValue (the value that the variable gets filled with before any data is written to it, defaults given in the dict netCDF4.default_fillvals). If fill_value is set to False, then the variable is not pre-filled.

If the optional keyword parameters least_significant_digit or significant_digits are specified, variable data will be truncated (quantized). In conjunction with compression=’zlib’ this produces ‘lossy’, but significantly more efficient compression. For example, if least_significant_digit=1, data will be quantized using numpy.around(scale*data)/scale, where scale = 2**bits, and bits is determined so that a precision of 0.1 is retained (in this case bits=4). From the [PSL metadata conventions](http://www.esrl.noaa.gov/psl/data/gridded/conventions/cdc_netcdf_standard.shtml): “least_significant_digit – power of ten of the smallest decimal place in unpacked data that is a reliable value.” Default is None, or no quantization, or ‘lossless’ compression. If significant_digits=3 then the data will be quantized so that three significant digits are retained, independent of the floating point exponent. The keyword argument quantize_mode controls the quantization algorithm (default ‘BitGroom’, ‘BitRound’ and ‘GranularBitRound’ also available). The ‘GranularBitRound’ algorithm may result in better compression for typical geophysical datasets. This significant_digits kwarg is only available with netcdf-c >= 4.9.0, and only works with NETCDF4 or NETCDF4_CLASSIC formatted files.

When creating variables in a NETCDF4 or NETCDF4_CLASSIC formatted file, HDF5 creates something called a ‘chunk cache’ for each variable. The default size of the chunk cache may be large enough to completely fill available memory when creating thousands of variables. The optional keyword chunk_cache allows you to reduce (or increase) the size of the default chunk cache when creating a variable. The setting only persists as long as the Dataset is open - you can use the set_var_chunk_cache method to change it the next time the Dataset is opened. Warning - messing with this parameter can seriously degrade performance.

The return value is the Variable class instance describing the new variable.

A list of names corresponding to netCDF variable attributes can be obtained with the Variable method Variable.ncattrs. A dictionary containing all the netCDF attribute name/value pairs is provided by the __dict__ attribute of a Variable instance.

Variable instances behave much like array objects. Data can be assigned to or retrieved from a variable with indexing and slicing operations on the Variable instance. A Variable instance has six Dataset standard attributes: dimensions, dtype, shape, ndim, name and least_significant_digit. Application programs should never modify these attributes. The dimensions attribute is a tuple containing the names of the dimensions associated with this variable. The dtype attribute is a string describing the variable’s data type (i4, f8, S1, etc). The shape attribute is a tuple describing the current sizes of all the variable’s dimensions. The name attribute is a string containing the name of the Variable instance. The least_significant_digit attributes describes the power of ten of the smallest decimal place in the data the contains a reliable value. assigned to the Variable instance. The ndim attribute is the number of variable dimensions.

delncattr(name)#

`delncattr(self,name,value)`

delete a netCDF dataset or group attribute. Use if you need to delete a netCDF attribute with the same name as one of the reserved python attributes.

filepath(encoding=None)#

`filepath(self,encoding=None)`

Get the file system path (or the opendap URL) which was used to open/create the Dataset. Requires netcdf >= 4.1.2. The path is decoded into a string using sys.getfilesystemencoding() by default, this can be changed using the encoding kwarg.

static fromcdl(cdlfilename, ncfilename=None, mode='a', format='NETCDF4')#

`fromcdl(cdlfilename, ncfilename=None, mode=’a’,format=’NETCDF4’)`

call [ncgen][ncgen] via subprocess to create Dataset from [CDL][cdl] text representation. Requires [ncgen][ncgen] to be installed and in $PATH.

`cdlfilename`: CDL file.

`ncfilename`: netCDF file to create. If not given, CDL filename with suffix replaced by .nc is used..

`mode`: Access mode to open Dataset (Default ‘a’).

`format`: underlying file format to use (one of ‘NETCDF4’, ‘NETCDF4_CLASSIC’, ‘NETCDF3_CLASSIC’, ‘NETCDF3_64BIT_OFFSET’ or ‘NETCDF3_64BIT_DATA’. Default ‘NETCDF4’.

Dataset instance for ncfilename is returned.

[ncgen]: https://www.unidata.ucar.edu/software/netcdf/docs/netcdf_utilities_guide.html#ncgen_guide [cdl]: https://www.unidata.ucar.edu/software/netcdf/docs/netcdf_utilities_guide.html#cdl_guide

get_variables_by_attributes(**kwargs)#

`get_variables_by_attributes(self, **kwargs)`

Returns a list of variables that match specific conditions.

Can pass in key=value parameters and variables are returned that contain all of the matches. For example,

`python >>> # Get variables with x-axis attribute. >>> vs = nc.get_variables_by_attributes(axis='X') >>> # Get variables with matching "standard_name" attribute >>> vs = nc.get_variables_by_attributes(standard_name='northward_sea_water_velocity') `

Can pass in key=callable parameter and variables are returned if the callable returns True. The callable should accept a single parameter, the attribute value. None is given as the attribute value when the attribute does not exist on the variable. For example,

`python >>> # Get Axis variables >>> vs = nc.get_variables_by_attributes(axis=lambda v: v in ['X', 'Y', 'Z', 'T']) >>> # Get variables that don't have an "axis" attribute >>> vs = nc.get_variables_by_attributes(axis=lambda v: v is None) >>> # Get variables that have a "grid_mapping" attribute >>> vs = nc.get_variables_by_attributes(grid_mapping=lambda v: v is not None) `

getncattr(name, encoding='utf-8')#

`getncattr(self,name)`

retrieve a netCDF dataset or group attribute. Use if you need to get a netCDF attribute with the same name as one of the reserved python attributes.

option kwarg encoding can be used to specify the character encoding of a string attribute (default is utf-8).

has_blosc_filter()#: `has_blosc_filter(self)` returns True if blosc compression filter is available

has_bzip2_filter()#: `has_bzip2_filter(self)` returns True if bzip2 compression filter is available

has_szip_filter()#: `has_szip_filter(self)` returns True if szip compression filter is available

has_zstd_filter()#: `has_zstd_filter(self)` returns True if zstd compression filter is available

isopen()#

`isopen(self)`

Is the Dataset open or closed?

name#: string name of Group instance

ncattrs()#

`ncattrs(self)`

return netCDF global attribute names for this Dataset or Group in a list.

renameAttribute(oldname, newname)#

`renameAttribute(self, oldname, newname)`

rename a Dataset or Group attribute named oldname to newname.

renameDimension(oldname, newname)#

`renameDimension(self, oldname, newname)`

rename a Dimension named oldname to newname.

renameGroup(oldname, newname)#

`renameGroup(self, oldname, newname)`

rename a Group named oldname to newname (requires netcdf >= 4.3.1).

renameVariable(oldname, newname)#

`renameVariable(self, oldname, newname)`

rename a Variable named oldname to newname

set_always_mask(value)#

`set_always_mask(self, True_or_False)`

Call Variable.set_always_mask for all variables contained in this Dataset or Group, as well as for all variables in all its subgroups.

`True_or_False`: Boolean determining if automatic conversion of masked arrays with no missing values to regular numpy arrays shall be applied for all variables. Default True. Set to False to restore the default behaviour in versions prior to 1.4.1 (numpy array returned unless missing values are present, otherwise masked array returned).